v13.0.0-22 -- distribution files

2017-10-07 00:46:32 +02:00
121 changed files with 42671 additions and 14824 deletions
--- a/.babelrc
+++ b/.babelrc
@@ -0,0 +1,12 @@
+{
+  "presets": [
+    ["latest", {
+      "es2015": {
+        "modules": false
+      }
+    }]
+  ],
+  "plugins": [
+    "external-helpers"
+  ]
+}
--- a/.flowconfig
+++ b/.flowconfig
@@ -0,0 +1,12 @@
+[ignore]
+.*/node_modules/.*
+.*/dist/.*
+.*/build/.*
+
+[include]
+./src/
+
+[libs]
+./declarations/
+
+[options]
--- a/.github/workflows/nodejs.yml
+++ b/.github/workflows/nodejs.yml
@@ -1,31 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [10.x, 12.x, 13.x]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    - run: npm run lint
-    - run: npm run test-extensive
-      env:
-        CI: true
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
 node_modules
-dist
-.vscode
-docs
+bower_components
+/y.*
+/examples/yjs-dist.js*
--- a/.jsdoc.json
+++ b/.jsdoc.json
@@ -1,52 +0,0 @@
-{
-  "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": {
-      "yjs.dev": "Website",
-      "docs.yjs.dev": "Docs",
-      "discuss.yjs.dev": "Forum",
-      "https://gitter.im/Yjs/community": "Chat"
-    },
-    "logo": {
-      "url": "https://yjs.dev/images/logo/yjs-512x512.png",
-      "width": "162px",
-      "height": "162px",
-      "link": "/"
-    },
-    "tabNames": {
-      "api": "API",
-      "tutorials": "Examples"
-    },
-    "footerText": "Shared Editing",
-    "css": [
-      "./style.css"
-    ],
-    "default": {
-      "staticFiles": {
-          "include": []
-      }
-    }
-  },
-  "opts": {
-    "destination": "./docs/",
-    "encoding": "utf8",
-    "private": false,
-    "recurse": true,
-    "template": "./node_modules/tui-jsdoc-template"
-  }
-}
--- a/.markdownlint.json
+++ b/.markdownlint.json
@@ -1,4 +0,0 @@
-{
-  "default": true,
-  "no-inline-html": false
-}
--- a/README.md
+++ b/README.md
--- a/examples/ace/index.html
+++ b/examples/ace/index.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style type="text/css" media="screen">
+    #aceContainer {
+        position: absolute;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
+    }
+    .inserted {
+      position:absolute;
+      z-index:20;
+      background-color: #FFC107;
+    }
+    .deleted {
+      position:absolute;
+      z-index:20;
+      background-color: #FFC107;
+    }
+    </style>
+  </head>
+  <body>
+
+    <div id="aceContainer"></div>
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="../bower_components/ace-builds/src/ace.js"></script>
+
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/ace/index.js
+++ b/examples/ace/index.js
@@ -0,0 +1,24 @@
+/* global Y, ace */
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'ace-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    ace: 'Text' // y.share.textarea is of type Y.Text
+  }
+}).then(function (y) {
+  window.yAce = y
+
+  // bind the textarea to a shared text element
+  var editor = ace.edit('aceContainer')
+  editor.setTheme('ace/theme/chrome')
+  editor.getSession().setMode('ace/mode/javascript')
+
+  y.share.ace.bindAce(editor)
+})
--- a/examples/bower.json
+++ b/examples/bower.json
@@ -0,0 +1,19 @@
+{
+  "name": "yjs-examples",
+  "version": "0.0.0",
+  "homepage": "y-js.org",
+  "authors": [
+    "Kevin Jahns <kevin.jahns@rwth-aachen.de>"
+  ],
+  "description": "Examples for Yjs",
+  "license": "MIT",
+  "ignore": [],
+  "dependencies": {
+    "quill": "^1.0.0-rc.2",
+    "ace": "~1.2.3",
+    "ace-builds": "~1.2.3",
+    "jquery": "~2.2.2",
+    "d3": "^3.5.16",
+    "codemirror": "^5.25.0"
+  }
+}
--- a/examples/chat/index.html
+++ b/examples/chat/index.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <style>
+      #chat p span {
+        color: blue;
+      }
+    </style>
+    <div id="chat"></div>
+    <form id="chatform">
+      <input name="username" type="text" style="width:15%;">
+      <input name="message" type="text" style="width:60%;">
+      <input type="submit" value="Send">
+    </form>
+    <script src="../../y.js"></script>
+    <script src="../../../y-array/y-array.js"></script>
+    <script src="../../../y-map/dist/y-map.js"></script>
+    <script src="../../../y-text/dist/y-text.js"></script>
+    <script src="../../../y-memory/y-memory.js"></script>
+    <script src="../../../y-websockets-client/dist/y-websockets-client.js"></script>
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/chat/index.js
+++ b/examples/chat/index.js
@@ -0,0 +1,73 @@
+/* global Y, chat */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'chat-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    chat: 'Array'
+  }
+}).then(function (y) {
+  window.yChat = y
+  // This functions inserts a message at the specified position in the DOM
+  function appendMessage (message, position) {
+    var p = document.createElement('p')
+    var uname = document.createElement('span')
+    uname.appendChild(document.createTextNode(message.username + ': '))
+    p.appendChild(uname)
+    p.appendChild(document.createTextNode(message.message))
+    document.querySelector('#chat').insertBefore(p, chat.children[position] || null)
+  }
+  // This function makes sure that only 7 messages exist in the chat history.
+  // The rest is deleted
+  function cleanupChat () {
+    if (y.share.chat.length > 7) {
+      y.share.chat.delete(0, y.chat.length - 7)
+    }
+  }
+  // Insert the initial content
+  y.share.chat.toArray().forEach(appendMessage)
+  cleanupChat()
+
+  // whenever content changes, make sure to reflect the changes in the DOM
+  y.share.chat.observe(function (event) {
+    if (event.type === 'insert') {
+      for (let i = 0; i < event.length; i++) {
+        appendMessage(event.values[i], event.index + i)
+      }
+    } else if (event.type === 'delete') {
+      for (let i = 0; i < event.length; i++) {
+        chat.children[event.index].remove()
+      }
+    }
+    // concurrent insertions may result in a history > 7, so cleanup here
+    cleanupChat()
+  })
+  document.querySelector('#chatform').onsubmit = function (event) {
+    // the form is submitted
+    var message = {
+      username: this.querySelector('[name=username]').value,
+      message: this.querySelector('[name=message]').value
+    }
+    if (message.username.length > 0 && message.message.length > 0) {
+      if (y.share.chat.length > 6) {
+        // If we are goint to insert the 8th element, make sure to delete first.
+        y.share.chat.delete(0)
+      }
+      // Here we insert a message in the shared chat type.
+      // This will call the observe function (see line 40)
+      // and reflect the change in the DOM
+      y.share.chat.push([message])
+      this.querySelector('[name=message]').value = ''
+    }
+    // Do not send this form!
+    event.preventDefault()
+    return false
+  }
+})
--- a/examples/codemirror/index.html
+++ b/examples/codemirror/index.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+  <head>
+  </head>
+  <body>
+    <div id="codeMirrorContainer"></div>
+
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="../bower_components/codemirror/lib/codemirror.js"></script>
+    <script src="../bower_components/codemirror/mode/javascript/javascript.js"></script>
+    <link rel="stylesheet" href="../bower_components/codemirror/lib/codemirror.css">
+    <style>
+      .CodeMirror {
+        position: fixed;
+        top: 0;
+        left: 0;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/codemirror/index.js
+++ b/examples/codemirror/index.js
@@ -0,0 +1,24 @@
+/* global Y, CodeMirror */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'codemirror-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    codemirror: 'Text' // y.share.codemirror is of type Y.Text
+  }
+}).then(function (y) {
+  window.yCodeMirror = y
+
+  var editor = CodeMirror(document.querySelector('#codeMirrorContainer'), {
+    mode: 'javascript',
+    lineNumbers: true
+  })
+  y.share.codemirror.bindCodeMirror(editor)
+})
--- a/examples/drawing/index.html
+++ b/examples/drawing/index.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<body>
+  <style>
+    path {
+      fill: none;
+      stroke: blue;
+      stroke-width: 1px;
+      stroke-linejoin: round;
+      stroke-linecap: round;
+    }
+  </style>
+  <button type="button" id="clearDrawingCanvas">Clear Drawing</button>
+  <svg id="drawingCanvas" viewbox="0 0 100 100" width="100%"></svg>
+  <script src="../../y.js"></script>
+  <script src="../../../y-array/y-array.js"></script>
+  <script src="../../../y-map/dist/y-map.js"></script>
+  <script src="../../../y-memory/y-memory.js"></script>
+  <script src="../../../y-websockets-client/y-websockets-client.js"></script>
+  <script src="../bower_components/d3/d3.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/drawing/index.js
+++ b/examples/drawing/index.js
@@ -0,0 +1,84 @@
+/* globals Y, d3 */
+'strict mode'
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'drawing-example',
+    url: 'localhost:1234'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    drawing: 'Array'
+  }
+}).then(function (y) {
+  window.yDrawing = y
+  var drawing = y.share.drawing
+  var renderPath = d3.svg.line()
+    .x(function (d) { return d[0] })
+    .y(function (d) { return d[1] })
+    .interpolate('basis')
+
+  var svg = d3.select('#drawingCanvas')
+    .call(d3.behavior.drag()
+      .on('dragstart', dragstart)
+      .on('drag', drag)
+      .on('dragend', dragend))
+
+  // create line from a shared array object and update the line when the array changes
+  function drawLine (yarray) {
+    var line = svg.append('path').datum(yarray.toArray())
+    line.attr('d', renderPath)
+    yarray.observe(function (event) {
+      // we only implement insert events that are appended to the end of the array
+      event.values.forEach(function (value) {
+        line.datum().push(value)
+      })
+      line.attr('d', renderPath)
+    })
+  }
+  // call drawLine every time an array is appended
+  y.share.drawing.observe(function (event) {
+    if (event.type === 'insert') {
+      event.values.forEach(drawLine)
+    } else {
+      // just remove all elements (thats what we do anyway)
+      svg.selectAll('path').remove()
+    }
+  })
+  // draw all existing content
+  for (var i = 0; i < drawing.length; i++) {
+    drawLine(drawing.get(i))
+  }
+
+  // clear canvas on request
+  document.querySelector('#clearDrawingCanvas').onclick = function () {
+    drawing.delete(0, drawing.length)
+  }
+
+  var sharedLine = null
+  function dragstart () {
+    drawing.insert(drawing.length, [Y.Array])
+    sharedLine = drawing.get(drawing.length - 1)
+  }
+
+  // After one dragged event is recognized, we ignore them for 33ms.
+  var ignoreDrag = null
+  function drag () {
+    if (sharedLine != null && ignoreDrag == null) {
+      ignoreDrag = window.setTimeout(function () {
+        ignoreDrag = null
+      }, 33)
+      sharedLine.push([d3.mouse(this)])
+    }
+  }
+
+  function dragend () {
+    sharedLine = null
+    window.clearTimeout(ignoreDrag)
+    ignoreDrag = null
+  }
+})
--- a/examples/html-editor/index.html
+++ b/examples/html-editor/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+</head>
+  <!-- jquery is not required for y-xml. It is just here for convenience, and to test batch operations. -->
+  <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
+  <script src="../yjs-dist.js"></script>
+  <script src="./index.js"></script>
+</head>
+<body contenteditable="true">
+</body>
+</html>
--- a/examples/html-editor/index.js
+++ b/examples/html-editor/index.js
@@ -0,0 +1,21 @@
+/* global Y */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    url: 'http://127.0.0.1:1234',
+    room: 'html-editor-example6'
+    // maxBufferLength: 100
+  },
+  share: {
+    xml: 'XmlFragment()' // y.share.xml is of type Y.Xml with tagname "p"
+  }
+}).then(function (y) {
+  window.yXml = y
+  // Bind children of XmlFragment to the document.body
+  window.yXml.share.xml.bindToDom(document.body)
+})
--- a/examples/indexeddb/index.html
+++ b/examples/indexeddb/index.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+  <head>
+  </head>
+  <body>
+    <div id="codeMirrorContainer"></div>
+    <script src="../bower_components/codemirror/lib/codemirror.js"></script>
+    <script src="../bower_components/codemirror/mode/javascript/javascript.js"></script>
+    <link rel="stylesheet" href="../bower_components/codemirror/lib/codemirror.css">
+    <style>
+      .CodeMirror {
+        position: fixed;
+        top: 0;
+        left: 0;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+    <script type="module" src="./index.js"></script>
+  </body>
+</html>
--- a/examples/indexeddb/index.js
+++ b/examples/indexeddb/index.js
@@ -0,0 +1,24 @@
+/* global Y, CodeMirror */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'codemirror-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    codemirror: 'Text' // y.share.codemirror is of type Y.Text
+  }
+}).then(function (y) {
+  window.yCodeMirror = y
+
+  var editor = CodeMirror(document.querySelector('#codeMirrorContainer'), {
+    mode: 'javascript',
+    lineNumbers: true
+  })
+  y.share.codemirror.bindCodeMirror(editor)
+})
--- a/examples/infiniteyjs/index.html
+++ b/examples/infiniteyjs/index.html
@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html>
+<body>
+  <style>
+    .wrapper {
+      display: grid;
+      grid-template-columns: repeat(3, 1fr);
+      grid-gap: 7px;
+    }
+    .one {
+      grid-column: 1 ;
+    }
+    .two { 
+      grid-column: 2;
+    }
+    .three {
+      grid-column: 3;
+    }
+    textarea {
+      width: calc(100% - 10px)
+    }
+    .editor-container {
+      background-color: #4caf50;
+      padding: 4px 5px 10px 5px;
+      border-radius: 11px;
+    }
+    .editor-container[disconnected] {
+      background-color: red;
+    }
+    .disconnected-info {
+      display: none;
+    }
+    .editor-container[disconnected] .disconnected-info {
+      display: inline;
+    }
+  </style>
+  <div class="wrapper">
+    <div id="container1" class="one editor-container">
+      <h1>Server 1 <span class="disconnected-info">(disconnected)</span></h1>
+      <textarea id="textarea1" rows=40 autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+    </div>
+    <div id="container2" class="two editor-container">
+      <h1>Server 2 <span class="disconnected-info">(disconnected)</span></h1>
+      <textarea id="textarea2" rows=40 autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+    </div>
+    <div id="container3" class="three editor-container">
+      <h1>Server 3 <span class="disconnected-info">(disconnected)</span></h1>
+      <textarea id="textarea3" rows=40 autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+    </div>
+  </div>
+  <script src="../../y.js"></script>
+  <script src="../../../y-array/y-array.js"></script>
+  <script src="../../../y-text/dist/y-text.js"></script>
+  <script src="../../../y-memory/y-memory.js"></script>
+  <script src="../../../y-websockets-client/y-websockets-client.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/infiniteyjs/index.js
+++ b/examples/infiniteyjs/index.js
@@ -0,0 +1,64 @@
+/* global Y */
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Textarea-example',
+    url: 'https://yjs-v13.herokuapp.com/'
+  },
+  share: {
+    textarea: 'Text'
+  }
+}).then(function (y) {
+  window.y1 = y
+  y.share.textarea.bind(document.getElementById('textarea1'))
+})
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Textarea-example',
+    url: 'https://yjs-v13-second.herokuapp.com/'
+  },
+  share: {
+    textarea: 'Text'
+  }
+}).then(function (y) {
+  window.y2 = y
+  y.share.textarea.bind(document.getElementById('textarea2'))
+  y.connector.socket.on('connection', function () {
+    document.getElementById('container2').removeAttribute('disconnected')
+  })
+  y.connector.socket.on('disconnect', function () {
+    document.getElementById('container2').setAttribute('disconnected', true)
+  })
+})
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Textarea-example',
+    url: 'https://yjs-v13-third.herokuapp.com/'
+  },
+  share: {
+    textarea: 'Text'
+  }
+}).then(function (y) {
+  window.y3 = y
+  y.share.textarea.bind(document.getElementById('textarea3'))
+  y.connector.socket.on('connection', function () {
+    document.getElementById('container3').removeAttribute('disconnected')
+  })
+  y.connector.socket.on('disconnect', function () {
+    document.getElementById('container3').setAttribute('disconnected', true)
+  })
+})
--- a/examples/jigsaw/index.html
+++ b/examples/jigsaw/index.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <style type="text/css">
+    .draggable {
+      cursor: move;
+    }
+  </style>
+</head>
+<body>
+  <svg id="puzzle-example" width="100%" viewBox="0 0 800 800">
+    <g>
+      <path d="M 311.76636,154.23389 C 312.14136,171.85693 318.14087,184.97998 336.13843,184.23047 C 354.13647,183.48047 351.88647,180.48096 354.88599,178.98096 C 357.8855,177.48096 368.38452,170.35693 380.00806,169.98193 C 424.61841,168.54297 419.78296,223.6001 382.25757,223.6001 C 377.75806,223.6001 363.51001,219.10107 356.38599,211.97656 C 349.26196,204.85254 310.64185,207.10254 314.76636,236.34863 C 316.34888,247.5708 324.08374,267.90723 324.84595,286.23486 C 325.29321,296.99414 323.17603,307.00635 321.58911,315.6377 C 360.11353,305.4585 367.73462,304.30518 404.00513,312.83936 C 410.37915,314.33887 436.62573,310.21436 421.25269,290.3418 C 405.87964,270.46924 406.25464,248.34717 417.12817,240.84814 C 428.00171,233.34912 446.74976,228.84961 457.99829,234.09912 C 469.24683,239.34814 484.61987,255.84619 475.24585,271.59424 C 465.87231,287.34229 452.74878,290.7168 456.49829,303.84033 C 460.2478,316.96387 479.74536,320.33838 500.74292,321.83789 C 509.70142,322.47803 527.97192,323.28467 542.10864,320.12939 C 549.91821,318.38672 556.92212,315.89502 562.46753,313.56396 C 561.40796,277.80664 560.84888,245.71729 560.3606,241.97314 C 558.85278,230.41455 542.49536,217.28564 525.86499,223.2251 C 520.61548,225.1001 519.86548,231.84912 505.24243,232.59912 C 444.92798,235.69238 462.06958,143.26709 525.86499,180.48096 C 539.52759,188.45068 575.19409,190.7583 570.10913,156.85889 C 567.85962,141.86035 553.98608,102.86523 553.98608,102.86523 C 553.98608,102.86523 477.23755,111.82227 451.99878,91.991699 C 441.50024,83.74292 444.87476,69.494629 449.37427,61.245605 C 453.87378,52.996582 465.12231,46.622559 464.74731,36.123779 C 463.02563,-12.086426 392.96704,-10.902832 396.5061,36.873535 C 397.25562,46.997314 406.62964,52.621582 410.75415,60.495605 C 420.00757,78.161377 405.50024,96.073486 384.50757,99.490723 C 377.36206,100.65381 349.17505,102.65332 320.39429,102.23486 C 319.677,102.22461 318.95923,102.21143 318.24194,102.19775 C 315.08423,120.9751 311.55688,144.39697 311.76636,154.23389 z " style="fill:#f2c569;stroke:#000000" id="path2502"/>
+      <path d="M 500.74292,321.83789 C 479.74536,320.33838 460.2478,316.96387 456.49829,303.84033 C 452.74878,290.7168 465.87231,287.34229 475.24585,271.59424 C 484.61987,255.84619 469.24683,239.34814 457.99829,234.09912 C 446.74976,228.84961 428.00171,233.34912 417.12817,240.84814 C 406.25464,248.34717 405.87964,270.46924 421.25269,290.3418 C 436.62573,310.21436 410.37915,314.33887 404.00513,312.83936 C 367.73462,304.30518 360.11353,305.4585 321.58911,315.6377 C 320.56372,321.21484 319.75854,326.2207 320.01538,330.46191 C 320.76538,342.83545 329.3894,385.95508 327.8894,392.7041 C 326.3894,399.45312 313.64136,418.20117 297.89331,407.32715 C 282.14526,396.45361 276.52075,393.4541 265.27222,394.5791 C 254.02368,395.70361 239.77563,402.07812 239.77563,419.32568 C 239.77563,436.57373 250.27417,449.69727 268.64673,447.82227 C 287.36353,445.9126 317.92163,423.11035 325.63989,452.69678 C 330.1394,469.94434 330.51392,487.19238 330.1394,498.44092 C 329.95825,503.87646 326.09985,518.06592 322.16089,531.28125 C 353.2854,532.73682 386.47095,531.26611 394.2561,529.93701 C 430.30933,523.78174 429.31909,496.09766 412.62866,477.44385 C 406.25464,470.31934 401.75513,455.32129 405.87964,444.82275 C 414.07056,423.97314 458.8064,422.17773 473.37134,438.82324 C 483.86987,450.82178 475.99585,477.44385 468.49683,482.69287 C 453.52222,493.17529 457.22485,516.83008 473.37134,528.06201 C 504.79126,549.91943 572.35913,535.56152 572.35913,535.56152 C 572.35913,535.56152 567.85962,498.06592 567.48462,471.81934 C 567.10962,445.57275 589.60669,450.07227 593.3562,450.07227 C 597.10571,450.07227 604.22974,455.32129 609.47925,459.4458 C 614.72876,463.57031 618.85327,469.94434 630.85181,470.69434 C 677.43726,473.60596 674.58813,420.7373 631.97632,413.32666 C 623.35229,411.82666 614.72876,416.32617 603.10522,424.57519 C 591.48169,432.82422 577.23315,425.32519 570.10913,417.45117 C 566.07788,412.99561 563.8479,360.16406 562.46753,313.56396 C 556.92212,315.89502 549.91821,318.38672 542.10864,320.12939 C 527.97192,323.28467 509.70142,322.47803 500.74292,321.83789 z " style="fill:#f3f3d6;stroke:#000000" id="path2504"/>
+      <path d="M 240.52563,141.86035 C 257.60327,159.6499 243.94507,188.68799 214.65356,190.22949 C 185.09448,191.78516 164.66675,157.17822 190.28589,136.61621 C 200.49585,128.42139 198.05786,114.12158 179.78296,106.98975 C 154.4187,97.091553 90.54419,107.73975 90.54419,107.73975 C 90.54419,107.73975 100.88794,135.11328 101.41772,168.48242 C 101.79272,192.104 68.796875,189.47949 63.172607,186.85498 C 57.54834,184.23047 45.924805,173.73145 37.675781,173.73145 C -14.411865,173.73145 -10.013184,245.84375 39.925537,232.22412 C 48.174316,229.97461 56.42334,220.97559 68.796875,222.47559 C 81.17041,223.9751 87.544434,232.59912 87.544434,246.09766 C 87.544434,252.51709 87.0354,281.24268 86.340576,312.87012 C 119.15894,313.67676 160.60962,314.46582 170.03442,313.58887 C 186.15698,312.08936 195.90601,301.59033 188.40698,293.3418 C 180.90796,285.09277 156.16089,256.59619 179.03296,239.34814 C 201.90503,222.10059 235.65112,231.84912 239.77563,247.22217 C 243.90015,262.59521 240.52563,273.46924 234.90112,279.09326 C 229.27661,284.71777 210.52905,298.96582 221.40259,308.71484 C 232.27661,318.46338 263.77222,330.83691 302.39282,320.71338 C 309.58862,318.82715 315.92114,317.13525 321.58911,315.6377 C 323.17603,307.00635 325.29321,296.99414 324.84595,286.23486 C 324.08374,267.90723 316.34888,247.5708 314.76636,236.34863 C 310.64185,207.10254 349.26196,204.85254 356.38599,211.97656 C 363.51001,219.10107 377.75806,223.6001 382.25757,223.6001 C 419.78296,223.6001 424.61841,168.54297 380.00806,169.98193 C 368.38452,170.35693 357.8855,177.48096 354.88599,178.98096 C 351.88647,180.48096 354.13647,183.48047 336.13843,184.23047 C 318.14087,184.97998 312.14136,171.85693 311.76636,154.23389 C 311.55688,144.39697 315.08423,120.9751 318.24194,102.19775 C 290.37524,101.67725 262.46069,98.968262 254.39868,97.991211 C 233.38013,95.443359 217.17456,117.53662 240.52563,141.86035 z " style="fill:#bebcdb;stroke:#000000" id="path2506"/>
+      <path d="M 325.63989,452.69678 C 317.92163,423.11035 287.36353,445.9126 268.64673,447.82227 C 250.27417,449.69727 239.77563,436.57373 239.77563,419.32568 C 239.77563,402.07812 254.02368,395.70361 265.27222,394.5791 C 276.52075,393.4541 282.14526,396.45361 297.89331,407.32715 C 313.64136,418.20117 326.3894,399.45313 327.8894,392.7041 C 329.3894,385.95508 320.76538,342.83545 320.01538,330.46191 C 319.75855,326.2207 320.56372,321.21484 321.58911,315.6377 C 315.92114,317.13525 309.58862,318.82715 302.39282,320.71338 C 263.77222,330.83691 232.27661,318.46338 221.40259,308.71484 C 210.52905,298.96582 229.27661,284.71777 234.90112,279.09326 C 240.52563,273.46924 243.90015,262.59521 239.77563,247.22217 C 235.65112,231.84912 201.90503,222.10059 179.03296,239.34814 C 156.16089,256.59619 180.90796,285.09277 188.40698,293.3418 C 195.90601,301.59033 186.15698,312.08936 170.03442,313.58887 C 160.60962,314.46582 119.15894,313.67676 86.340576,312.87012 C 85.573975,347.74561 84.581299,386.15088 83.794922,402.07812 C 82.295166,432.44922 109.29175,422.32568 115.66577,420.82568 C 122.04028,419.32568 126.16479,409.57715 143.03735,408.45215 C 185.9231,405.59326 186.09985,466.69629 144.16235,467.69482 C 128.41431,468.06982 113.79126,451.19678 108.16675,447.44727 C 102.54272,443.69775 87.919433,442.94775 83.794922,457.9458 C 82.01709,464.41113 78.118652,481.65137 78.098144,496.18994 C 78.071045,515.38037 82.295166,531.81201 82.295166,531.81201 C 82.295166,531.81201 105.54224,526.5625 149.41187,526.5625 C 193.28149,526.5625 199.65552,547.93506 194.78101,558.80859 C 189.90649,569.68213 181.28296,568.93213 179.40796,583.18066 C 172.7063,634.11133 253.34106,631.08203 249.14917,584.68018 C 247.96948,571.62354 237.16528,571.66699 232.27661,557.68359 C 222.17944,528.80273 244.64966,523.56299 257.39819,524.68799 C 263.59351,525.23437 290.95679,529.73389 320.75757,531.21582 C 321.22437,531.23877 321.69312,531.25928 322.16089,531.28125 C 326.09985,518.06592 329.95825,503.87646 330.1394,498.44092 C 330.51392,487.19238 330.1394,469.94434 325.63989,452.69678 z " style="fill:#d3ea9d;stroke:#000000" id="path2508"/>
+		</g>
+  </svg>
+  <script src="../../y.js"></script>
+  <script src="../../../y-map/dist/y-map.js"></script>
+  <script src="../../../y-memory/y-memory.js"></script>
+  <script src="../../../y-websockets-client/y-websockets-client.js"></script>
+  <script src="../bower_components/d3/d3.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/jigsaw/index.js
+++ b/examples/jigsaw/index.js
@@ -0,0 +1,74 @@
+/* @flow */
+/* global Y, d3 */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Puzzle-example',
+    url: 'http://localhost:1234'
+  },
+  share: {
+    piece1: 'Map',
+    piece2: 'Map',
+    piece3: 'Map',
+    piece4: 'Map'
+  }
+}).then(function (y) {
+  window.yJigsaw = y
+  var origin // mouse start position - translation of piece
+  var drag = d3.behavior.drag()
+    .on('dragstart', function (params) {
+      // get the translation of the element
+      var translation = d3
+        .select(this)
+        .attr('transform')
+        .slice(10, -1)
+        .split(',')
+        .map(Number)
+      // mouse coordinates
+      var mouse = d3.mouse(this.parentNode)
+      origin = {
+        x: mouse[0] - translation[0],
+        y: mouse[1] - translation[1]
+      }
+    })
+    .on('drag', function () {
+      var mouse = d3.mouse(this.parentNode)
+      var x = mouse[0] - origin.x // =^= mouse - mouse at dragstart + translation at dragstart
+      var y = mouse[1] - origin.y
+      d3.select(this).attr('transform', 'translate(' + x + ',' + y + ')')
+    })
+    .on('dragend', function (piece, i) {
+      // save the current translation of the puzzle piece
+      var mouse = d3.mouse(this.parentNode)
+      var x = mouse[0] - origin.x
+      var y = mouse[1] - origin.y
+      piece.set('translation', {x: x, y: y})
+    })
+
+  var data = [y.share.piece1, y.share.piece2, y.share.piece3, y.share.piece4]
+  var pieces = d3.select(document.querySelector('#puzzle-example')).selectAll('path').data(data)
+
+  pieces
+    .classed('draggable', true)
+    .attr('transform', function (piece) {
+      var translation = piece.get('translation') || {x: 0, y: 0}
+      return 'translate(' + translation.x + ',' + translation.y + ')'
+    }).call(drag)
+
+  data.forEach(function (piece) {
+    piece.observe(function () {
+      // whenever a property of a piece changes, update the translation of the pieces
+      pieces
+        .transition()
+        .attr('transform', function (piece) {
+          var translation = piece.get('translation') || {x: 0, y: 0}
+          return 'translate(' + translation.x + ',' + translation.y + ')'
+        })
+    })
+  })
+})
--- a/examples/monaco/index.html
+++ b/examples/monaco/index.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+  <head>
+  </head>
+  <body>
+    <div id="monacoContainer"></div>
+    <style>
+      #monacoContainer {
+        position: fixed;
+        top: 0;
+        left: 0;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+    <script src="../bower_components/yjs/y.js"></script>
+    <script src="../bower_components/y-array/y-array.js"></script>
+    <script src="../bower_components/y-text/y-text.js"></script>
+    <script src="../bower_components/y-websockets-client/y-websockets-client.js"></script>
+    <script src="../bower_components/y-memory/y-memory.js"></script>
+    <script src="../node_modules/monaco-editor/min/vs/loader.js"></script>
+    <script src="./index.js"></script>
+  </body>
+</html>
--- a/examples/monaco/index.js
+++ b/examples/monaco/index.js
@@ -0,0 +1,30 @@
+/* global Y, monaco */
+
+require.config({ paths: { 'vs': '../node_modules/monaco-editor/min/vs' } })
+
+require(['vs/editor/editor.main'], function () {
+  // Initialize a shared object. This function call returns a promise!
+  Y({
+    db: {
+      name: 'memory'
+    },
+    connector: {
+      name: 'websockets-client',
+      room: 'monaco-example'
+    },
+    sourceDir: '/bower_components',
+    share: {
+      monaco: 'Text' // y.share.monaco is of type Y.Text
+    }
+  }).then(function (y) {
+    window.yMonaco = y
+
+    // Create Monaco editor
+    var editor = monaco.editor.create(document.getElementById('monacoContainer'), {
+      language: 'javascript'
+    })
+
+    // Bind to y.share.monaco
+    y.share.monaco.bindMonaco(editor)
+  })
+})
--- a/examples/package-lock.json
+++ b/examples/package-lock.json
--- a/examples/package.json
+++ b/examples/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "examples",
+  "version": "0.0.0",
+  "description": "",
+  "scripts": {
+    "dist": "rollup -c",
+    "watch": "rollup -cw"
+  },
+  "author": "Kevin Jahns",
+  "license": "MIT",
+  "dependencies": {
+    "monaco-editor": "^0.8.3"
+  },
+  "devDependencies": {
+    "standard": "^10.0.2"
+  },
+  "standard": {
+    "ignore": ["bower_components"]
+  }
+}
--- a/examples/quill/index.html
+++ b/examples/quill/index.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <!-- quill does not include dist files! We are using the hosted version instead -->
+  <!--link rel="stylesheet" href="../bower_components/quill/dist/quill.snow.css" /-->
+  <link href="https://cdn.quilljs.com/1.0.4/quill.snow.css" rel="stylesheet">
+  <link href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.css" rel="stylesheet">
+  <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/styles/monokai-sublime.min.css" rel="stylesheet">
+  <style>
+    #quill-container {
+      border: 1px solid gray;
+      box-shadow: 0px 0px 10px gray;
+    }
+  </style>
+</head>
+<body>
+  <div id="quill-container">
+    <div id="quill">
+    </div>
+  </div>
+
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.js" type="text/javascript"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/highlight.min.js" type="text/javascript"></script>
+  <script src="https://cdn.quilljs.com/1.0.4/quill.js"></script>
+  <!-- quill does not include dist files! We are using the hosted version instead (see above)
+  <script src="../bower_components/quill/dist/quill.js"></script>
+  -->
+  <script src="../../y.js"></script>
+  <script src="../../../y-array/y-array.js"></script>
+  <script src="../../../y-richtext/dist/y-richtext.js"></script>
+  <script src="../../../y-memory/y-memory.js"></script>
+  <script src="../../../y-websockets-client/y-websockets-client.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/quill/index.js
+++ b/examples/quill/index.js
@@ -0,0 +1,40 @@
+/* global Y, Quill */
+
+// initialize a shared object. This function call returns a promise!
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'richtext-example-quill-1.0-test',
+    url: 'http://localhost:1234'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    richtext: 'Richtext' // y.share.richtext is of type Y.Richtext
+  }
+}).then(function (y) {
+  window.yQuill = y
+
+  // create quill element
+  window.quill = new Quill('#quill', {
+    modules: {
+      formula: true,
+      syntax: true,
+      toolbar: [
+        [{ size: ['small', false, 'large', 'huge'] }],
+        ['bold', 'italic', 'underline'],
+        [{ color: [] }, { background: [] }],    // Snow theme fills in values
+        [{ script: 'sub' }, { script: 'super' }],
+        ['link', 'image'],
+        ['link', 'code-block'],
+        [{ list: 'ordered' }]
+      ]
+    },
+    theme: 'snow'
+  })
+  // bind quill to richtext type
+  y.share.richtext.bind(window.quill)
+})
--- a/examples/rollup.config.js
+++ b/examples/rollup.config.js
@@ -0,0 +1,27 @@
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+
+var pkg = require('./package.json')
+
+export default {
+  entry: 'yjs-dist.esm',
+  dest: 'yjs-dist.js',
+  moduleName: 'Y',
+  format: 'umd',
+  plugins: [
+    nodeResolve({
+      main: true,
+      module: true,
+      browser: true
+    }),
+    commonjs()
+  ],
+  sourceMap: true,
+  banner: `
+/**
+ * ${pkg.name} - ${pkg.description}
+ * @version v${pkg.version}
+ * @license ${pkg.license}
+ */
+`
+}
--- a/examples/serviceworker/index.html
+++ b/examples/serviceworker/index.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <!-- quill does not include dist files! We are using the hosted version instead -->
+  <!--link rel="stylesheet" href="../bower_components/quill/dist/quill.snow.css" /-->
+  <link href="https://cdn.quilljs.com/1.0.4/quill.snow.css" rel="stylesheet">
+  <link href="//cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.css" rel="stylesheet">
+  <link href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/styles/monokai-sublime.min.css" rel="stylesheet">
+  <style>
+    #quill-container {
+      border: 1px solid gray;
+      box-shadow: 0px 0px 10px gray;
+    }
+  </style>
+</head>
+<body>
+  <div id="quill-container">
+    <div id="quill">
+    </div>
+  </div>
+
+  <script src="//cdnjs.cloudflare.com/ajax/libs/KaTeX/0.5.1/katex.min.js" type="text/javascript"></script>
+  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.2.0/highlight.min.js" type="text/javascript"></script>
+  <script src="https://cdn.quilljs.com/1.0.4/quill.js"></script>
+  <!-- quill does not include dist files! We are using the hosted version instead (see above)
+  <script src="../bower_components/quill/dist/quill.js"></script>
+  -->
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/serviceworker/index.js
+++ b/examples/serviceworker/index.js
@@ -0,0 +1,49 @@
+/* global Y, Quill */
+
+// register yjs service worker
+if ('serviceWorker' in navigator) {
+  // Register service worker
+  // it is important to copy yjs-sw-template to the root directory!
+  navigator.serviceWorker.register('./yjs-sw-template.js').then(function (reg) {
+    console.log('Yjs service worker registration succeeded. Scope is ' + reg.scope)
+  }).catch(function (err) {
+    console.error('Yjs service worker registration failed with error ' + err)
+  })
+}
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'serviceworker',
+    room: 'ServiceWorkerExample2'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    richtext: 'Richtext' // y.share.richtext is of type Y.Richtext
+  }
+}).then(function (y) {
+  window.yServiceWorker = y
+
+  // create quill element
+  window.quill = new Quill('#quill', {
+    modules: {
+      formula: true,
+      syntax: true,
+      toolbar: [
+        [{ size: ['small', false, 'large', 'huge'] }],
+        ['bold', 'italic', 'underline'],
+        [{ color: [] }, { background: [] }],    // Snow theme fills in values
+        [{ script: 'sub' }, { script: 'super' }],
+        ['link', 'image'],
+        ['link', 'code-block'],
+        [{ list: 'ordered' }]
+      ]
+    },
+    theme: 'snow'
+  })
+  // bind quill to richtext type
+  y.share.richtext.bind(window.quill)
+})
--- a/examples/serviceworker/yjs-sw-template.js
+++ b/examples/serviceworker/yjs-sw-template.js
@@ -0,0 +1,22 @@
+/* eslint-env worker */
+
+// copy and modify this file
+
+self.DBConfig = {
+  name: 'indexeddb'
+}
+self.ConnectorConfig = {
+  name: 'websockets-client',
+  // url: '..',
+  options: {
+    jsonp: false
+  }
+}
+
+importScripts(
+  '/bower_components/yjs/y.js',
+  '/bower_components/y-memory/y-memory.js',
+  '/bower_components/y-indexeddb/y-indexeddb.js',
+  '/bower_components/y-websockets-client/y-websockets-client.js',
+  '/bower_components/y-serviceworker/yjs-sw-include.js'
+)
--- a/examples/textarea/index.html
+++ b/examples/textarea/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<body>
+  <textarea style="width:80%;" rows=40 id="textfield" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+  <script src="../../y.js"></script>
+  <script src="../../../y-array/y-array.js"></script>
+  <script src="../../../y-text/y-text.js"></script>
+  <script src="../../../y-websockets-client/y-websockets-client.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/examples/textarea/index.js
+++ b/examples/textarea/index.js
@@ -0,0 +1,23 @@
+/* global Y */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'Textarea-example2',
+    // url: '//localhost:1234',
+    url: 'https://yjs-v13.herokuapp.com/'
+  },
+  share: {
+    textarea: 'Text'
+  },
+  timeout: 5000 // reject if no connection was established within 5 seconds
+}).then(function (y) {
+  window.yTextarea = y
+
+  // bind the textarea to a shared text element
+  y.share.textarea.bind(document.getElementById('textfield'))
+})
--- a/examples/xml/index.html
+++ b/examples/xml/index.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+</head>
+  <!-- jquery is not required for y-xml. It is just here for convenience, and to test batch operations. -->
+  <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
+  <script src="../yjs-dist.js"></script>
+  <script src="./index.js"></script>
+</head>
+<body>
+  <h1> Shared DOM Example </h1>
+  <p> Use native DOM function or jQuery to manipulate the shared DOM (window.sharedDom). </p>
+  <div class="command">
+    <button type="button">Execute</button>
+    <input type="text" value='$(sharedDom).append("<h3>Appended headline</h3>")' size="40"/>
+  </div>
+  <div class="command">
+    <button type="button">Execute</button>
+    <input type="text" value='$(sharedDom).attr("align","right")' size="40"/>
+  </div>
+  <div class="command">
+    <button type="button">Execute</button>
+    <input type="text" value='$(sharedDom).attr("style","color:blue;")' size="40"/>
+  </div>
+
+  <script>
+    var commands = document.querySelectorAll(".command");
+    Array.prototype.forEach.call(document.querySelectorAll('.command'), function (command) {
+      var execute = function(){
+        eval(command.querySelector("input").value);
+      }
+      command.querySelector("button").onclick = execute
+      $(command.querySelector("input")).keyup(function (e) {
+        if (e.keyCode == 13) {
+          execute()
+        }
+      })
+    })
+  </script>
+</body>
+</html>
--- a/examples/xml/index.js
+++ b/examples/xml/index.js
@@ -0,0 +1,23 @@
+/* global Y */
+
+// initialize a shared object. This function call returns a promise!
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    // url: 'http://127.0.0.1:1234',
+    url: 'http://192.168.178.81:1234',
+    room: 'Xml-example'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    xml: 'Xml("p")' // y.share.xml is of type Y.Xml with tagname "p"
+  }
+}).then(function (y) {
+  window.yXml = y
+  // bind xml type to a dom, and put it in body
+  window.sharedDom = y.share.xml.getDom()
+  document.body.appendChild(window.sharedDom)
+})
--- a/examples/yjs-dist.esm
+++ b/examples/yjs-dist.esm
@@ -0,0 +1,12 @@
+
+import Y from '../src/y.js'
+import yArray from '../../y-array/src/y-array.js'
+import yIndexedDB from '../../y-indexeddb/src/y-indexeddb.js'
+import yMap from '../../y-map/src/y-map.js'
+import yText from '../../y-text/src/y-text.js'
+import yXml from '../../y-xml/src/y-xml.js'
+import yWebsocketsClient from '../../y-websockets-client/src/y-websockets-client.js'
+
+Y.extend(yArray, yIndexedDB, yMap, yText, yXml, yWebsocketsClient)
+
+export default Y
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,80 +1,70 @@
 {
  "name": "yjs",
-  "version": "13.3.2",
-  "description": "Shared Editing Library",
-  "main": "./dist/yjs.cjs",
-  "module": "./dist/yjs.mjs",
-  "unpkg": "./dist/yjs.mjs",
-  "types": "./dist/src/index.d.ts",
-  "sideEffects": false,
-  "funding": {
-    "type": "GitHub Sponsors ❤",
-    "url": "https://github.com/sponsors/dmonad"
-  },
+  "version": "13.0.0-22",
+  "description": "A framework for real-time p2p shared editing on any data",
+  "main": "./y.node.js",
+  "browser": "./y.js",
+  "module": "./src/y.js",
  "scripts": {
-    "test": "npm run dist && node ./dist/tests.cjs --repitition-time 50",
-    "test-extensive": "npm run lint && npm run dist && node ./dist/tests.cjs --production --repitition-time 10000",
-    "dist": "rm -rf dist && rollup -c && tsc",
-    "watch": "rollup -wc",
-    "lint": "markdownlint README.md && standard && tsc",
-    "docs": "rm -rf docs; jsdoc --configure ./.jsdoc.json --verbose --readme ./README.md --package ./package.json || true",
-    "serve-docs": "npm run docs && http-server ./docs/",
-    "preversion": "npm run lint && PRODUCTION=1 npm run dist && npm run docs && node ./dist/tests.cjs --repitition-time 1000 && test -e dist/src/index.d.ts && test -e dist/yjs.cjs && test -e dist/yjs.cjs",
-    "debug": "concurrently 'http-server -o test.html' 'npm run watch'",
-    "trace-deopt": "clear && rollup -c  && node --trace-deopt dist/test.cjs",
-    "trace-opt": "clear && rollup -c  && node --trace-opt dist/test.cjs"
+    "test": "npm run lint",
+    "debug": "concurrently 'rollup -wc rollup.test.js' 'cutest-serve y.test.js -o'",
+    "lint": "standard",
+    "dist": "rollup -c rollup.browser.js; rollup -c rollup.node.js",
+    "watch": "concurrently 'rollup -wc rollup.browser.js' 'rollup -wc rollup.node.js'",
+    "postversion": "npm run dist",
+    "postpublish": "tag-dist-files --overwrite-existing-tag"
  },
  "files": [
-    "dist/*",
-    "src/*",
-    "tests/*",
-    "docs/*"
+    "y.*"
  ],
-  "dictionaries": {
-    "doc": "docs",
-    "test": "tests"
-  },
  "standard": {
    "ignore": [
-      "/dist",
-      "/node_modules",
-      "/docs"
+      "/y.js",
+      "/y.js.map"
    ]
  },
  "repository": {
    "type": "git",
-    "url": "https://github.com/yjs/yjs.git"
+    "url": "https://github.com/y-js/yjs.git"
  },
  "keywords": [
    "Yjs",
-    "CRDT",
-    "offline",
-    "shared editing",
-    "concurrency",
-    "collaboration"
+    "OT",
+    "Collaboration",
+    "Synchronization",
+    "ShareJS",
+    "Coweb",
+    "Concurrency"
  ],
  "author": "Kevin Jahns",
-  "email": "kevin.jahns@protonmail.com",
+  "email": "kevin.jahns@rwth-aachen.de",
  "license": "MIT",
  "bugs": {
-    "url": "https://github.com/yjs/yjs/issues"
-  },
-  "homepage": "https://yjs.dev",
-  "dependencies": {
-    "lib0": "^0.2.32"
+    "url": "https://github.com/y-js/yjs/issues"
  },
+  "homepage": "http://y-js.org",
  "devDependencies": {
-    "@rollup/plugin-commonjs": "^11.1.0",
-    "@rollup/plugin-node-resolve": "^7.1.3",
-    "concurrently": "^3.6.1",
-    "http-server": "^0.12.3",
-    "jsdoc": "^3.6.4",
-    "markdownlint-cli": "^0.23.2",
-    "rollup": "^1.32.1",
-    "rollup-cli": "^1.0.9",
-    "standard": "^14.3.4",
-    "tui-jsdoc-template": "^1.2.2",
-    "typescript": "^3.9.6",
-    "y-protocols": "^0.2.3"
+    "babel-cli": "^6.24.1",
+    "babel-plugin-external-helpers": "^6.22.0",
+    "babel-plugin-transform-regenerator": "^6.24.1",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-latest": "^6.24.1",
+    "chance": "^1.0.9",
+    "concurrently": "^3.4.0",
+    "cutest": "^0.1.9",
+    "rollup-plugin-babel": "^2.7.1",
+    "rollup-plugin-commonjs": "^8.0.2",
+    "rollup-plugin-inject": "^2.0.0",
+    "rollup-plugin-multi-entry": "^2.0.1",
+    "rollup-plugin-node-resolve": "^3.0.0",
+    "rollup-plugin-uglify": "^1.0.2",
+    "rollup-regenerator-runtime": "^6.23.1",
+    "rollup-watch": "^3.2.2",
+    "standard": "^10.0.2",
+    "tag-dist-files": "^0.1.6"
+  },
+  "dependencies": {
+    "debug": "^2.6.8",
+    "utf-8": "^1.0.0"
  }
 }
--- a/rollup.browser.js
+++ b/rollup.browser.js
@@ -0,0 +1,41 @@
+import babel from 'rollup-plugin-babel'
+import uglify from 'rollup-plugin-uglify'
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+var pkg = require('./package.json')
+
+export default {
+  entry: 'src/y.js',
+  moduleName: 'Y',
+  format: 'umd',
+  plugins: [
+    nodeResolve({
+      main: true,
+      module: true,
+      browser: true
+    }),
+    commonjs(),
+    babel(),
+    uglify({
+      output: {
+        comments: function (node, comment) {
+          var text = comment.value
+          var type = comment.type
+          if (type === 'comment2') {
+            // multiline comment
+            return /@license/i.test(text)
+          }
+        }
+      }
+    })
+  ],
+  dest: 'y.js',
+  sourceMap: true,
+  banner: `
+/**
+ * ${pkg.name} - ${pkg.description}
+ * @version v${pkg.version}
+ * @license ${pkg.license}
+ */
+`
+}
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -1,94 +0,0 @@
-import nodeResolve from '@rollup/plugin-node-resolve'
-import commonjs from '@rollup/plugin-commonjs'
-
-const localImports = process.env.LOCALIMPORTS
-
-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 (localImports) {
-      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
-  }
-}
-
-export default [{
-  input: './src/index.js',
-  output: {
-    name: 'Y',
-    file: 'dist/yjs.cjs',
-    format: 'cjs',
-    sourcemap: true,
-    paths: path => {
-      if (/^lib0\//.test(path)) {
-        return `lib0/dist/${path.slice(5, -3)}.cjs`
-      }
-      return path
-    }
-  },
-  external: id => /^lib0\//.test(id)
-}, {
-  input: './src/index.js',
-  output: {
-    name: 'Y',
-    file: 'dist/yjs.mjs',
-    format: 'esm',
-    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({
-      mainFields: ['module', 'browser', 'main']
-    }),
-    commonjs()
-  ]
-}, {
-  input: './tests/index.js',
-  output: {
-    name: 'test',
-    file: 'dist/tests.cjs',
-    format: 'cjs',
-    sourcemap: true
-  },
-  plugins: [
-    debugResolve,
-    nodeResolve({
-      mainFields: ['module', 'main']
-    }),
-    commonjs()
-  ],
-  external: ['isomorphic.js']
-}]
--- a/rollup.node.js
+++ b/rollup.node.js
@@ -0,0 +1,26 @@
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+var pkg = require('./package.json')
+
+export default {
+  entry: 'src/y.js',
+  moduleName: 'Y',
+  format: 'umd',
+  plugins: [
+    nodeResolve({
+      main: true,
+      module: true,
+      browser: true
+    }),
+    commonjs()
+  ],
+  dest: 'y.node.js',
+  sourceMap: true,
+  banner: `
+/**
+ * ${pkg.name} - ${pkg.description}
+ * @version v${pkg.version}
+ * @license ${pkg.license}
+ */
+`
+}
--- a/rollup.test.js
+++ b/rollup.test.js
@@ -0,0 +1,20 @@
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+import multiEntry from 'rollup-plugin-multi-entry'
+
+export default {
+  entry: 'test/*.js',
+  moduleName: 'y-tests',
+  format: 'umd',
+  plugins: [
+    nodeResolve({
+      main: true,
+      module: true,
+      browser: true
+    }),
+    commonjs(),
+    multiEntry()
+  ],
+  dest: 'y.test.js',
+  sourceMap: true
+}
--- a/src/Connector.js
+++ b/src/Connector.js
@@ -0,0 +1,318 @@
+import { BinaryEncoder, BinaryDecoder } from './Encoding.js'
+import { sendSyncStep1, computeMessageSyncStep1, computeMessageSyncStep2, computeMessageUpdate } from './MessageHandler.js'
+
+export default function extendConnector (Y/* :any */) {
+  class AbstractConnector {
+    /*
+      opts contains the following information:
+       role : String Role of this client ("master" or "slave")
+    */
+    constructor (y, opts) {
+      this.y = y
+      if (opts == null) {
+        opts = {}
+      }
+      this.opts = opts
+      // Prefer to receive untransformed operations. This does only work if
+      // this client receives operations from only one other client.
+      // In particular, this does not work with y-webrtc.
+      // It will work with y-websockets-client
+      this.preferUntransformed = opts.preferUntransformed || false
+      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.log = Y.debug('y:connector')
+      this.logMessage = Y.debug('y:connector-message')
+      this.y.db.forwardAppliedOperations = opts.forwardAppliedOperations || false
+      this.role = opts.role
+      this.connections = new Map()
+      this.isSynced = false
+      this.userEventListeners = []
+      this.whenSyncedListeners = []
+      this.currentSyncTarget = null
+      this.debug = opts.debug === true
+      this.broadcastOpBuffer = []
+      this.protocolVersion = 11
+      this.authInfo = opts.auth || null
+      this.checkAuth = opts.checkAuth || function () { return Promise.resolve('write') } // default is everyone has write access
+      if (opts.generateUserId !== false) {
+        this.setUserId(Y.utils.generateUserId())
+      }
+      if (opts.maxBufferLength == null) {
+        this.maxBufferLength = -1
+      } else {
+        this.maxBufferLength = opts.maxBufferLength
+      }
+    }
+
+    reconnect () {
+      this.log('reconnecting..')
+      return this.y.db.startGarbageCollector()
+    }
+
+    disconnect () {
+      this.log('discronnecting..')
+      this.connections = new Map()
+      this.isSynced = false
+      this.currentSyncTarget = null
+      this.whenSyncedListeners = []
+      this.y.db.stopGarbageCollector()
+      return this.y.db.whenTransactionsFinished()
+    }
+
+    repair () {
+      this.log('Repairing the state of Yjs. This can happen if messages get lost, and Yjs detects that something is wrong. If this happens often, please report an issue here: https://github.com/y-js/yjs/issues')
+      this.isSynced = false
+      this.connections.forEach((user, userId) => {
+        user.isSynced = false
+        this._syncWithUser(userId)
+      })
+    }
+
+    setUserId (userId) {
+      if (this.userId == null) {
+        if (!Number.isInteger(userId)) {
+          let err = new Error('UserId must be an integer!')
+          this.y.emit('error', err)
+          throw err
+        }
+        this.log('Set userId to "%s"', userId)
+        this.userId = userId
+        return this.y.db.setUserId(userId)
+      } else {
+        return null
+      }
+    }
+
+    onUserEvent (f) {
+      this.userEventListeners.push(f)
+    }
+
+    removeUserEventListener (f) {
+      this.userEventListeners = this.userEventListeners.filter(g => f !== g)
+    }
+
+    userLeft (user) {
+      if (this.connections.has(user)) {
+        this.log('%s: User left %s', this.userId, user)
+        this.connections.delete(user)
+        // check if isSynced event can be sent now
+        this._setSyncedWith(null)
+        for (var f of this.userEventListeners) {
+          f({
+            action: 'userLeft',
+            user: user
+          })
+        }
+      }
+    }
+
+    userJoined (user, role, auth) {
+      if (role == null) {
+        throw new Error('You must specify the role of the joined user!')
+      }
+      if (this.connections.has(user)) {
+        throw new Error('This user already joined!')
+      }
+      this.log('%s: User joined %s', this.userId, user)
+      this.connections.set(user, {
+        uid: user,
+        isSynced: false,
+        role: role,
+        processAfterAuth: [],
+        auth: auth || null,
+        receivedSyncStep2: false
+      })
+      let defer = {}
+      defer.promise = new Promise(function (resolve) { defer.resolve = resolve })
+      this.connections.get(user).syncStep2 = defer
+      for (var f of this.userEventListeners) {
+        f({
+          action: 'userJoined',
+          user: user,
+          role: role
+        })
+      }
+      this._syncWithUser(user)
+    }
+
+    // Execute a function _when_ we are connected.
+    // If not connected, wait until connected
+    whenSynced (f) {
+      if (this.isSynced) {
+        f()
+      } else {
+        this.whenSyncedListeners.push(f)
+      }
+    }
+
+    _syncWithUser (userid) {
+      if (this.role === 'slave') {
+        return // "The current sync has not finished or this is controlled by a master!"
+      }
+      sendSyncStep1(this, userid)
+    }
+
+    _fireIsSyncedListeners () {
+      this.y.db.whenTransactionsFinished().then(() => {
+        if (!this.isSynced) {
+          this.isSynced = true
+          // It is safer to remove this!
+          // TODO: remove: this.garbageCollectAfterSync()
+          // call whensynced listeners
+          for (var f of this.whenSyncedListeners) {
+            f()
+          }
+          this.whenSyncedListeners = []
+        }
+      })
+    }
+
+    send (uid, buffer) {
+      if (!(buffer instanceof ArrayBuffer || buffer instanceof Uint8Array)) {
+        throw new Error('Expected Message to be an ArrayBuffer or Uint8Array - please don\'t use this method to send custom messages')
+      }
+      this.log('%s: Send \'%y\' to %s', this.userId, buffer, uid)
+      this.logMessage('Message: %Y', buffer)
+    }
+
+    broadcast (buffer) {
+      if (!(buffer instanceof ArrayBuffer || buffer instanceof Uint8Array)) {
+        throw new Error('Expected Message to be an ArrayBuffer or Uint8Array - please don\'t use this method to send custom messages')
+      }
+      this.log('%s: Broadcast \'%y\'', this.userId, buffer)
+      this.logMessage('Message: %Y', buffer)
+    }
+
+    /*
+      Buffer operations, and broadcast them when ready.
+    */
+    broadcastOps (ops) {
+      ops = ops.map(function (op) {
+        return Y.Struct[op.struct].encode(op)
+      })
+      var self = this
+      function broadcastOperations () {
+        if (self.broadcastOpBuffer.length > 0) {
+          let encoder = new BinaryEncoder()
+          encoder.writeVarString(self.opts.room)
+          encoder.writeVarString('update')
+          let ops = self.broadcastOpBuffer
+          let length = ops.length
+          let encoderPosLen = encoder.pos
+          encoder.writeUint32(0)
+          for (var i = 0; i < length && (self.maxBufferLength < 0 || encoder.length < self.maxBufferLength); i++) {
+            let op = ops[i]
+            Y.Struct[op.struct].binaryEncode(encoder, op)
+          }
+          encoder.setUint32(encoderPosLen, i)
+          self.broadcastOpBuffer = ops.slice(i)
+          self.broadcast(encoder.createBuffer())
+          if (i !== length) {
+            self.whenRemoteResponsive().then(broadcastOperations)
+          }
+        }
+      }
+      if (this.broadcastOpBuffer.length === 0) {
+        this.broadcastOpBuffer = ops
+        this.y.db.whenTransactionsFinished().then(broadcastOperations)
+      } else {
+        this.broadcastOpBuffer = this.broadcastOpBuffer.concat(ops)
+      }
+    }
+
+    /*
+     * Somehow check the responsiveness of the remote clients/server
+     * Default behavior:
+     *   Wait 100ms before broadcasting the next batch of operations
+     *
+     * Only used when maxBufferLength is set
+     *
+     */
+    whenRemoteResponsive () {
+      return new Promise(function (resolve) {
+        setTimeout(resolve, 100)
+      })
+    }
+
+    /*
+      You received a raw message, and you know that it is intended for Yjs. Then call this function.
+    */
+    receiveMessage (sender, buffer, skipAuth) {
+      skipAuth = skipAuth || false
+      if (!(buffer instanceof ArrayBuffer || buffer instanceof Uint8Array)) {
+        return Promise.reject(new Error('Expected Message to be an ArrayBuffer or Uint8Array!'))
+      }
+      if (sender === this.userId) {
+        return Promise.resolve()
+      }
+      let decoder = new BinaryDecoder(buffer)
+      let encoder = new BinaryEncoder()
+      let roomname = decoder.readVarString() // read room name
+      encoder.writeVarString(roomname)
+      let messageType = decoder.readVarString()
+      let senderConn = this.connections.get(sender)
+      this.log('%s: Receive \'%s\' from %s', this.userId, messageType, sender)
+      this.logMessage('Message: %Y', buffer)
+      if (senderConn == null && !skipAuth) {
+        throw new Error('Received message from unknown peer!')
+      }
+      if (messageType === 'sync step 1' || messageType === 'sync step 2') {
+        let auth = decoder.readVarUint()
+        if (senderConn.auth == null) {
+          senderConn.processAfterAuth.push([messageType, senderConn, decoder, encoder, sender])
+          // check auth
+          return this.checkAuth(auth, this.y, sender).then(authPermissions => {
+            if (senderConn.auth == null) {
+              senderConn.auth = authPermissions
+              this.y.emit('userAuthenticated', {
+                user: senderConn.uid,
+                auth: authPermissions
+              })
+            }
+            let messages = senderConn.processAfterAuth
+            senderConn.processAfterAuth = []
+
+            return messages.reduce((p, m) =>
+              p.then(() => this.computeMessage(m[0], m[1], m[2], m[3], m[4]))
+            , Promise.resolve())
+          })
+        }
+      }
+      if (skipAuth || senderConn.auth != null) {
+        return this.computeMessage(messageType, senderConn, decoder, encoder, sender, skipAuth)
+      } else {
+        senderConn.processAfterAuth.push([messageType, senderConn, decoder, encoder, sender, false])
+      }
+    }
+
+    computeMessage (messageType, senderConn, decoder, encoder, sender, skipAuth) {
+      if (messageType === 'sync step 1' && (senderConn.auth === 'write' || senderConn.auth === 'read')) {
+        // cannot wait for sync step 1 to finish, because we may wait for sync step 2 in sync step 1 (->lock)
+        computeMessageSyncStep1(decoder, encoder, this, senderConn, sender)
+        return this.y.db.whenTransactionsFinished()
+      } else if (messageType === 'sync step 2' && senderConn.auth === 'write') {
+        return computeMessageSyncStep2(decoder, encoder, this, senderConn, sender)
+      } else if (messageType === 'update' && (skipAuth || senderConn.auth === 'write')) {
+        return computeMessageUpdate(decoder, encoder, this, senderConn, sender)
+      } else {
+        return Promise.reject(new Error('Unable to receive message'))
+      }
+    }
+
+    _setSyncedWith (user) {
+      if (user != null) {
+        this.connections.get(user).isSynced = true
+      }
+      let conns = Array.from(this.connections.values())
+      if (conns.length > 0 && conns.every(u => u.isSynced)) {
+        this._fireIsSyncedListeners()
+      }
+    }
+  }
+  Y.AbstractConnector = AbstractConnector
+}
--- a/src/Database.js
+++ b/src/Database.js
@@ -0,0 +1,609 @@
+/* @flow */
+'use strict'
+
+export default function extendDatabase (Y /* :any */) {
+  /*
+    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 {
+    /* ::
+    y: YConfig;
+    forwardAppliedOperations: boolean;
+    listenersById: Object;
+    listenersByIdExecuteNow: Array<Object>;
+    listenersByIdRequestPending: boolean;
+    initializedTypes: Object;
+    whenUserIdSetListener: ?Function;
+    waitingTransactions: Array<Transaction>;
+    transactionInProgress: boolean;
+    executeOrder: Array<Object>;
+    gc1: Array<Struct>;
+    gc2: Array<Struct>;
+    gcTimeout: number;
+    gcInterval: any;
+    garbageCollect: Function;
+    executeOrder: Array<any>; // for debugging only
+    userId: UserId;
+    opClock: number;
+    transactionsFinished: ?{promise: Promise, resolve: any};
+    transact: (x: ?Generator) => any;
+    */
+    constructor (y, opts) {
+      this.y = y
+      opts.gc = opts.gc === true
+      this.dbOpts = opts
+      var os = this
+      this.userId = null
+      var resolve_
+      this.userIdPromise = new Promise(function (resolve) {
+        resolve_ = resolve
+      })
+      this.userIdPromise.resolve = resolve_
+      // whether to broadcast all applied operations (insert & delete hook)
+      this.forwardAppliedOperations = false
+      // 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.waitingTransactions = []
+      this.transactionInProgress = false
+      this.transactionIsFlushed = false
+      if (typeof YConcurrencyTestingMode !== 'undefined') {
+        this.executeOrder = []
+      }
+      this.gc1 = [] // first stage
+      this.gc2 = [] // second stage -> after that, remove the op
+
+      function garbageCollect () {
+        return os.whenTransactionsFinished().then(function () {
+          if (os.gcTimeout > 0 && (os.gc1.length > 0 || os.gc2.length > 0)) {
+            if (!os.y.connector.isSynced) {
+              console.warn('gc should be empty when not synced!')
+            }
+            return new Promise((resolve) => {
+              os.requestTransaction(function () {
+                if (os.y.connector != null && os.y.connector.isSynced) {
+                  for (var i = 0; i < os.gc2.length; i++) {
+                    var oid = os.gc2[i]
+                    this.garbageCollectOperation(oid)
+                  }
+                  os.gc2 = os.gc1
+                  os.gc1 = []
+                }
+                // TODO: Use setInterval here instead (when garbageCollect is called several times there will be several timeouts..)
+                if (os.gcTimeout > 0) {
+                  os.gcInterval = setTimeout(garbageCollect, os.gcTimeout)
+                }
+                resolve()
+              })
+            })
+          } else {
+            // TODO: see above
+            if (os.gcTimeout > 0) {
+              os.gcInterval = setTimeout(garbageCollect, os.gcTimeout)
+            }
+            return Promise.resolve()
+          }
+        })
+      }
+      this.garbageCollect = garbageCollect
+      this.startGarbageCollector()
+
+      this.repairCheckInterval = !opts.repairCheckInterval ? 6000 : opts.repairCheckInterval
+      this.opsReceivedTimestamp = new Date()
+      this.startRepairCheck()
+    }
+    startGarbageCollector () {
+      this.gc = this.dbOpts.gc
+      if (this.gc) {
+        this.gcTimeout = !this.dbOpts.gcTimeout ? 30000 : this.dbOpts.gcTimeout
+      } else {
+        this.gcTimeout = -1
+      }
+      if (this.gcTimeout > 0) {
+        this.garbageCollect()
+      }
+    }
+    startRepairCheck () {
+      var os = this
+      if (this.repairCheckInterval > 0) {
+        this.repairCheckIntervalHandler = setInterval(function repairOnMissingOperations () {
+          /*
+            Case 1. No ops have been received in a while (new Date() - os.opsReceivedTimestamp > os.repairCheckInterval)
+              - 1.1 os.listenersById is empty. Then the state was correct the whole time. -> Nothing to do (nor to update)
+              - 1.2 os.listenersById is not empty.
+                      * Then the state was incorrect for at least {os.repairCheckInterval} seconds.
+                      * -> Remove everything in os.listenersById and sync again (connector.repair())
+            Case 2. An op has been received in the last {os.repairCheckInterval } seconds.
+                    It is not yet necessary to check for faulty behavior. Everything can still resolve itself. Wait for more messages.
+                    If nothing was received for a while and os.listenersById is still not emty, we are in case 1.2
+                    -> Do nothing
+
+            Baseline here is: we really only have to catch case 1.2..
+          */
+          if (
+            new Date() - os.opsReceivedTimestamp > os.repairCheckInterval &&
+            Object.keys(os.listenersById).length > 0 // os.listenersById is not empty
+          ) {
+            // haven't received operations for over {os.repairCheckInterval} seconds, resend state vector
+            os.listenersById = {}
+            os.opsReceivedTimestamp = new Date() // update so you don't send repair several times in a row
+            os.y.connector.repair()
+          }
+        }, this.repairCheckInterval)
+      }
+    }
+    stopRepairCheck () {
+      clearInterval(this.repairCheckIntervalHandler)
+    }
+    queueGarbageCollector (id) {
+      if (this.y.connector.isSynced && this.gc) {
+        this.gc1.push(id)
+      }
+    }
+    emptyGarbageCollector () {
+      return new Promise(resolve => {
+        var check = () => {
+          if (this.gc1.length > 0 || this.gc2.length > 0) {
+            this.garbageCollect().then(check)
+          } else {
+            resolve()
+          }
+        }
+        setTimeout(check, 0)
+      })
+    }
+    addToDebug () {
+      if (typeof YConcurrencyTestingMode !== 'undefined') {
+        var command /* :string */ = 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
+      this.gc = false
+      this.gcTimeout = -1
+      return new Promise(function (resolve) {
+        self.requestTransaction(function () {
+          var ungc /* :Array<Struct> */ = self.gc1.concat(self.gc2)
+          self.gc1 = []
+          self.gc2 = []
+          for (var i = 0; i < ungc.length; i++) {
+            var op = this.getOperation(ungc[i])
+            if (op != null) {
+              delete op.gc
+              this.setOperation(op)
+            }
+          }
+          resolve()
+        })
+      })
+    }
+    /*
+      Try to add to GC.
+
+      TODO: rename this function
+
+      Rulez:
+      * Only gc if this user is online & gc turned on
+      * 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.store.gc &&
+        this.store.y.connector.isSynced
+      ) {
+        var gc = false
+        if (left != null && left.deleted === true) {
+          gc = true
+        } else if (op.content != null && op.content.length > 1) {
+          op = this.getInsertionCleanStart([op.id[0], op.id[1] + 1])
+          gc = true
+        }
+        if (gc) {
+          op.gc = true
+          this.setOperation(op)
+          this.store.queueGarbageCollector(op.id)
+          return true
+        }
+      }
+      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
+    }
+    destroyTypes () {
+      for (var key in this.initializedTypes) {
+        var type = this.initializedTypes[key]
+        if (type._destroy != null) {
+          type._destroy()
+        } else {
+          console.error('The type you included does not provide destroy functionality, it will remain in memory (updating your packages will help).')
+        }
+      }
+    }
+    destroy () {
+      clearTimeout(this.gcInterval)
+      this.gcInterval = null
+      this.stopRepairCheck()
+    }
+    setUserId (userId) {
+      if (!this.userIdPromise.inProgress) {
+        this.userIdPromise.inProgress = true
+        var self = this
+        self.requestTransaction(function () {
+          self.userId = userId
+          var state = this.getState(userId)
+          self.opClock = state.clock
+          self.userIdPromise.resolve(userId)
+        })
+      }
+      return this.userIdPromise
+    }
+    whenUserIdSet (f) {
+      this.userIdPromise.then(f)
+    }
+    getNextOpId (numberOfIds) {
+      if (numberOfIds == null) {
+        throw new Error('getNextOpId expects the number of created ids to create!')
+      } else if (this.userId == null) {
+        throw new Error('OperationStore not yet initialized!')
+      } else {
+        var id = [this.userId, this.opClock]
+        this.opClock += numberOfIds
+        return id
+      }
+    }
+    /*
+      Apply a list of operations.
+
+      * we save a timestamp, because we received new operations that could resolve ops in this.listenersById (see this.startRepairCheck)
+      * 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
+    */
+    applyOperations (decoder) {
+      this.opsReceivedTimestamp = new Date()
+      let length = decoder.readUint32()
+
+      for (var i = 0; i < length; i++) {
+        let o = Y.Struct.binaryDecodeOperation(decoder)
+        if (o.id == null || o.id[0] !== this.y.connector.userId) {
+          var required = Y.Struct[o.struct].requiredOps(o)
+          if (o.requires != null) {
+            required = required.concat(o.requires)
+          }
+          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 i = 0; i < ids.length; i++) {
+          let id = ids[i]
+          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 = 0; key < exeNow.length; key++) {
+          let o = exeNow[key].op
+          store.tryExecute.call(this, o)
+        }
+
+        for (var sid in ls) {
+          var l = ls[sid]
+          var id = JSON.parse(sid)
+          var op
+          if (typeof id[1] === 'string') {
+            op = this.getOperation(id)
+          } else {
+            op = this.getInsertion(id)
+          }
+          if (op == null) {
+            store.listenersById[sid] = l
+          } else {
+            for (let i = 0; i < l.length; i++) {
+              let listener = l[i]
+              let o = listener.op
+              if (--listener.missing === 0) {
+                store.tryExecute.call(this, o)
+              }
+            }
+          }
+        }
+      })
+    }
+    /*
+      Actually execute an operation, when all expected operations are available.
+    */
+    /* :: // TODO: this belongs somehow to transaction
+    store: Object;
+    getOperation: any;
+    isGarbageCollected: any;
+    addOperation: any;
+    whenOperationsExist: any;
+    */
+    tryExecute (op) {
+      this.store.addToDebug('this.store.tryExecute.call(this, ', JSON.stringify(op), ')')
+      if (op.struct === 'Delete') {
+        Y.Struct.Delete.execute.call(this, op)
+        // this is now called in Transaction.deleteOperation!
+        // this.store.operationAdded(this, op)
+      } else {
+        // check if this op was defined
+        var defined = this.getInsertion(op.id)
+        while (defined != null && defined.content != null) {
+          // check if this op has a longer content in the case it is defined
+          if (defined.id[1] + defined.content.length < op.id[1] + op.content.length) {
+            var overlapSize = defined.content.length - (op.id[1] - defined.id[1])
+            op.content.splice(0, overlapSize)
+            op.id = [op.id[0], op.id[1] + overlapSize]
+            op.left = Y.utils.getLastId(defined)
+            op.origin = op.left
+            defined = this.getOperation(op.id) // getOperation suffices here
+          } else {
+            break
+          }
+        }
+        if (defined == null) {
+          var opid = op.id
+          var isGarbageCollected = this.isGarbageCollected(opid)
+          if (!isGarbageCollected) {
+            // TODO: reduce number of get / put calls for op ..
+            Y.Struct[op.struct].execute.call(this, op)
+            this.addOperation(op)
+            this.store.operationAdded(this, op)
+            // operationAdded can change op..
+            op = this.getOperation(opid)
+            // if insertion, try to combine with left
+            this.tryCombineWithLeft(op)
+          }
+        }
+      }
+    }
+    /*
+     * Called by a transaction when an operation is added.
+     * This function is especially important for y-indexeddb, where several instances may share a single database.
+     * Every time an operation is created by one instance, it is send to all other instances and operationAdded is called
+     *
+     * If it's not a Delete operation:
+     *   * Checks if another operation is executable (listenersById)
+     *   * Update state, if possible
+     *
+     * Always:
+     *   * Call type
+     */
+    operationAdded (transaction, op) {
+      if (op.struct === 'Delete') {
+        var type = this.initializedTypes[JSON.stringify(op.targetParent)]
+        if (type != null) {
+          type._changed(transaction, op)
+        }
+      } else {
+        // increase SS
+        transaction.updateState(op.id[0])
+        var opLen = op.content != null ? op.content.length : 1
+        for (let i = 0; i < opLen; i++) {
+          // notify whenOperation listeners (by id)
+          var sid = JSON.stringify([op.id[0], op.id[1] + i])
+          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)]
+
+        // if parent is deleted, mark as gc'd and return
+        if (op.parent != null) {
+          var parentIsDeleted = transaction.isDeleted(op.parent)
+          if (parentIsDeleted) {
+            transaction.deleteList(op.id)
+            return
+          }
+        }
+
+        // notify parent, if it was instanciated as a custom type
+        if (t != null) {
+          let o = Y.utils.copyOperation(op)
+          t._changed(transaction, o)
+        }
+        if (!op.deleted) {
+          // Delete if DS says this is actually deleted
+          var len = op.content != null ? op.content.length : 1
+          var startId = op.id // You must not use op.id in the following loop, because op will change when deleted
+            // TODO: !! console.log('TODO: change this before commiting')
+          for (let i = 0; i < len; i++) {
+            var id = [startId[0], startId[1] + i]
+            var opIsDeleted = transaction.isDeleted(id)
+            if (opIsDeleted) {
+              var delop = {
+                struct: 'Delete',
+                target: id
+              }
+              this.tryExecute.call(transaction, delop)
+            }
+          }
+        }
+      }
+    }
+
+    whenTransactionsFinished () {
+      if (this.transactionInProgress) {
+        if (this.transactionsFinished == null) {
+          var resolve_
+          var promise = new Promise(function (resolve) {
+            resolve_ = resolve
+          })
+          this.transactionsFinished = {
+            resolve: resolve_,
+            promise: promise
+          }
+        }
+        return this.transactionsFinished.promise
+      } else {
+        return Promise.resolve()
+      }
+    }
+
+    // Check if there is another transaction request.
+    // * the last transaction is always a flush :)
+    getNextRequest () {
+      if (this.waitingTransactions.length === 0) {
+        if (this.transactionIsFlushed) {
+          this.transactionInProgress = false
+          this.transactionIsFlushed = false
+          if (this.transactionsFinished != null) {
+            this.transactionsFinished.resolve()
+            this.transactionsFinished = null
+          }
+          return null
+        } else {
+          this.transactionIsFlushed = true
+          return function () {
+            this.flush()
+          }
+        }
+      } else {
+        this.transactionIsFlushed = false
+        return this.waitingTransactions.shift()
+      }
+    }
+    requestTransaction (makeGen/* :any */, callImmediately) {
+      this.waitingTransactions.push(makeGen)
+      if (!this.transactionInProgress) {
+        this.transactionInProgress = true
+        setTimeout(() => {
+          this.transact(this.getNextRequest())
+        }, 0)
+      }
+    }
+    /*
+      Get a created/initialized type.
+    */
+    getType (id) {
+      return this.initializedTypes[JSON.stringify(id)]
+    }
+    /*
+      Init type. This is called when a remote operation is retrieved, and transformed to a type
+      TODO: delete type from store.initializedTypes[id] when corresponding id was deleted!
+    */
+    initType (id, args) {
+      var sid = JSON.stringify(id)
+      var t = this.store.initializedTypes[sid]
+      if (t == null) {
+        var op/* :MapStruct | ListStruct */ = this.getOperation(id)
+        if (op != null) {
+          t = Y[op.type].typeDefinition.initType.call(this, this.store, op, args)
+          this.store.initializedTypes[sid] = t
+        }
+      }
+      return t
+    }
+    /*
+     Create type. This is called when the local user creates a type (which is a synchronous action)
+    */
+    createType (typedefinition, id) {
+      var structname = typedefinition[0].struct
+      id = id || this.getNextOpId(1)
+      var op = Y.Struct[structname].create(id, typedefinition[1])
+      op.type = typedefinition[0].name
+
+      this.requestTransaction(function () {
+        if (op.id[0] === 0xFFFFFF) {
+          this.setOperation(op)
+        } else {
+          this.applyCreatedOperations([op])
+        }
+      })
+      var t = Y[op.type].typeDefinition.createType(this, op, typedefinition[1])
+      this.initializedTypes[JSON.stringify(op.id)] = t
+      return t
+    }
+  }
+  Y.AbstractDatabase = AbstractDatabase
+}
--- a/src/Encoding.js
+++ b/src/Encoding.js
@@ -0,0 +1,156 @@
+import utf8 from 'utf-8'
+
+const bits7 = 0b1111111
+const bits8 = 0b11111111
+
+export class BinaryEncoder {
+  constructor () {
+    this.data = []
+  }
+
+  get length () {
+    return this.data.length
+  }
+
+  get pos () {
+    return this.data.length
+  }
+
+  createBuffer () {
+    return Uint8Array.from(this.data).buffer
+  }
+
+  writeUint8 (num) {
+    this.data.push(num & bits8)
+  }
+
+  setUint8 (pos, num) {
+    this.data[pos] = num & bits8
+  }
+
+  writeUint16 (num) {
+    this.data.push(num & bits8, (num >>> 8) & bits8)
+  }
+
+  setUint16 (pos, num) {
+    this.data[pos] = num & bits8
+    this.data[pos + 1] = (num >>> 8) & bits8
+  }
+
+  writeUint32 (num) {
+    for (let i = 0; i < 4; i++) {
+      this.data.push(num & bits8)
+      num >>>= 8
+    }
+  }
+
+  setUint32 (pos, num) {
+    for (let i = 0; i < 4; i++) {
+      this.data[pos + i] = num & bits8
+      num >>>= 8
+    }
+  }
+
+  writeVarUint (num) {
+    while (num >= 0b10000000) {
+      this.data.push(0b10000000 | (bits7 & num))
+      num >>>= 7
+    }
+    this.data.push(bits7 & num)
+  }
+
+  writeVarString (str) {
+    let bytes = utf8.setBytesFromString(str)
+    let len = bytes.length
+    this.writeVarUint(len)
+    for (let i = 0; i < len; i++) {
+      this.data.push(bytes[i])
+    }
+  }
+
+  writeOpID (id) {
+    let user = id[0]
+    this.writeVarUint(user)
+    if (user !== 0xFFFFFF) {
+      this.writeVarUint(id[1])
+    } else {
+      this.writeVarString(id[1])
+    }
+  }
+}
+
+export class BinaryDecoder {
+  constructor (buffer) {
+    if (buffer instanceof ArrayBuffer) {
+      this.uint8arr = new Uint8Array(buffer)
+    } else if (buffer instanceof Uint8Array || (typeof Buffer !== 'undefined' && buffer instanceof Buffer)) {
+      this.uint8arr = buffer
+    } else {
+      throw new Error('Expected an ArrayBuffer or Uint8Array!')
+    }
+    this.pos = 0
+  }
+
+  skip8 () {
+    this.pos++
+  }
+
+  readUint8 () {
+    return this.uint8arr[this.pos++]
+  }
+
+  readUint32 () {
+    let uint =
+      this.uint8arr[this.pos] +
+      (this.uint8arr[this.pos + 1] << 8) +
+      (this.uint8arr[this.pos + 2] << 16) +
+      (this.uint8arr[this.pos + 3] << 24)
+    this.pos += 4
+    return uint
+  }
+
+  peekUint8 () {
+    return this.uint8arr[this.pos]
+  }
+
+  readVarUint () {
+    let num = 0
+    let len = 0
+    while (true) {
+      let r = this.uint8arr[this.pos++]
+      num = num | ((r & bits7) << len)
+      len += 7
+      if (r < 1 << 7) {
+        return num >>> 0 // return unsigned number!
+      }
+      if (len > 35) {
+        throw new Error('Integer out of range!')
+      }
+    }
+  }
+
+  readVarString () {
+    let len = this.readVarUint()
+    let bytes = new Array(len)
+    for (let i = 0; i < len; i++) {
+      bytes[i] = this.uint8arr[this.pos++]
+    }
+    return utf8.getStringFromBytes(bytes)
+  }
+
+  peekVarString () {
+    let pos = this.pos
+    let s = this.readVarString()
+    this.pos = pos
+    return s
+  }
+
+  readOpID () {
+    let user = this.readVarUint()
+    if (user !== 0xFFFFFF) {
+      return [user, this.readVarUint()]
+    } else {
+      return [user, this.readVarString()]
+    }
+  }
+}
--- a/src/MessageHandler.js
+++ b/src/MessageHandler.js
@@ -0,0 +1,193 @@
+
+import Y from './y.js'
+import { BinaryDecoder, BinaryEncoder } from './Encoding.js'
+
+export function formatYjsMessage (buffer) {
+  let decoder = new BinaryDecoder(buffer)
+  decoder.readVarString() // read roomname
+  let type = decoder.readVarString()
+  let strBuilder = []
+  strBuilder.push('\n === ' + type + ' ===\n')
+  if (type === 'update') {
+    logMessageUpdate(decoder, strBuilder)
+  } else if (type === 'sync step 1') {
+    logMessageSyncStep1(decoder, strBuilder)
+  } else if (type === 'sync step 2') {
+    logMessageSyncStep2(decoder, strBuilder)
+  } else {
+    strBuilder.push('-- Unknown message type - probably an encoding issue!!!')
+  }
+  return strBuilder.join('')
+}
+
+export function formatYjsMessageType (buffer) {
+  let decoder = new BinaryDecoder(buffer)
+  decoder.readVarString() // roomname
+  return decoder.readVarString()
+}
+
+export function logMessageUpdate (decoder, strBuilder) {
+  let len = decoder.readUint32()
+  for (let i = 0; i < len; i++) {
+    strBuilder.push(JSON.stringify(Y.Struct.binaryDecodeOperation(decoder)) + '\n')
+  }
+}
+
+export function computeMessageUpdate (decoder, encoder, conn) {
+  if (conn.y.db.forwardAppliedOperations || conn.y.persistence != null) {
+    let messagePosition = decoder.pos
+    let len = decoder.readUint32()
+    let delops = []
+    for (let i = 0; i < len; i++) {
+      let op = Y.Struct.binaryDecodeOperation(decoder)
+      if (op.struct === 'Delete') {
+        delops.push(op)
+      }
+    }
+    if (delops.length > 0) {
+      if (conn.y.db.forwardAppliedOperations) {
+        conn.broadcastOps(delops)
+      }
+      if (conn.y.persistence) {
+        conn.y.persistence.saveOperations(delops)
+      }
+    }
+    decoder.pos = messagePosition
+  }
+  conn.y.db.applyOperations(decoder)
+}
+
+export function sendSyncStep1 (conn, syncUser) {
+  conn.y.db.requestTransaction(function () {
+    let encoder = new BinaryEncoder()
+    encoder.writeVarString(conn.opts.room || '')
+    encoder.writeVarString('sync step 1')
+    encoder.writeVarString(conn.authInfo || '')
+    encoder.writeVarUint(conn.protocolVersion)
+    let preferUntransformed = conn.preferUntransformed && this.os.length === 0 // TODO: length may not be defined
+    encoder.writeUint8(preferUntransformed ? 1 : 0)
+    this.writeStateSet(encoder)
+    conn.send(syncUser, encoder.createBuffer())
+  })
+}
+
+export function logMessageSyncStep1 (decoder, strBuilder) {
+  let auth = decoder.readVarString()
+  let protocolVersion = decoder.readVarUint()
+  let preferUntransformed = decoder.readUint8() === 1
+  strBuilder.push(`
+  - auth: "${auth}"
+  - protocolVersion: ${protocolVersion}
+  - preferUntransformed: ${preferUntransformed}
+`)
+  logSS(decoder, strBuilder)
+}
+
+export function computeMessageSyncStep1 (decoder, encoder, conn, senderConn, sender) {
+  let protocolVersion = decoder.readVarUint()
+  let preferUntransformed = decoder.readUint8() === 1
+
+  // check protocol version
+  if (protocolVersion !== conn.protocolVersion) {
+    console.warn(
+      `You tried to sync with a yjs instance that has a different protocol version
+      (You: ${protocolVersion}, Client: ${protocolVersion}).
+      The sync was stopped. You need to upgrade your dependencies (especially Yjs & the Connector)!
+      `)
+    conn.y.destroy()
+  }
+
+  return conn.y.db.whenTransactionsFinished().then(() => {
+    // send sync step 2
+    conn.y.db.requestTransaction(function () {
+      encoder.writeVarString('sync step 2')
+      encoder.writeVarString(conn.authInfo || '')
+
+      if (preferUntransformed) {
+        encoder.writeUint8(1)
+        this.writeOperationsUntransformed(encoder)
+      } else {
+        encoder.writeUint8(0)
+        this.writeOperations(encoder, decoder)
+      }
+
+      this.writeDeleteSet(encoder)
+      conn.send(senderConn.uid, encoder.createBuffer())
+      senderConn.receivedSyncStep2 = true
+    })
+    return conn.y.db.whenTransactionsFinished().then(() => {
+      if (conn.role === 'slave') {
+        sendSyncStep1(conn, sender)
+      }
+    })
+  })
+}
+
+export function logSS (decoder, strBuilder) {
+  strBuilder.push('  == SS: \n')
+  let len = decoder.readUint32()
+  for (let i = 0; i < len; i++) {
+    let user = decoder.readVarUint()
+    let clock = decoder.readVarUint()
+    strBuilder.push(`     ${user}: ${clock}\n`)
+  }
+}
+
+export function logOS (decoder, strBuilder) {
+  strBuilder.push('  == OS: \n')
+  let len = decoder.readUint32()
+  for (let i = 0; i < len; i++) {
+    let op = Y.Struct.binaryDecodeOperation(decoder)
+    strBuilder.push(JSON.stringify(op) + '\n')
+  }
+}
+
+export function logDS (decoder, strBuilder) {
+  strBuilder.push('  == DS: \n')
+  let len = decoder.readUint32()
+  for (let i = 0; i < len; i++) {
+    let user = decoder.readVarUint()
+    strBuilder.push(`    User: ${user}: `)
+    let len2 = decoder.readVarUint()
+    for (let j = 0; j < len2; j++) {
+      let from = decoder.readVarUint()
+      let to = decoder.readVarUint()
+      let gc = decoder.readUint8() === 1
+      strBuilder.push(`[${from}, ${to}, ${gc}]`)
+    }
+  }
+}
+
+export function logMessageSyncStep2 (decoder, strBuilder) {
+  strBuilder.push('     - auth: ' + decoder.readVarString() + '\n')
+  let osTransformed = decoder.readUint8() === 1
+  strBuilder.push('     - osUntransformed: ' + osTransformed + '\n')
+  logOS(decoder, strBuilder)
+  if (osTransformed) {
+    logSS(decoder, strBuilder)
+  }
+  logDS(decoder, strBuilder)
+}
+
+export function computeMessageSyncStep2 (decoder, encoder, conn, senderConn, sender) {
+  var db = conn.y.db
+  let defer = senderConn.syncStep2
+
+  // apply operations first
+  db.requestTransaction(function () {
+    let osUntransformed = decoder.readUint8()
+    if (osUntransformed === 1) {
+      this.applyOperationsUntransformed(decoder)
+    } else {
+      this.store.applyOperations(decoder)
+    }
+  })
+  // then apply ds
+  db.requestTransaction(function () {
+    this.applyDeleteSet(decoder)
+  })
+  return db.whenTransactionsFinished().then(() => {
+    conn._setSyncedWith(sender)
+    defer.resolve()
+  })
+}
--- a/src/Notes.md
+++ b/src/Notes.md
@@ -0,0 +1,12 @@
+
+# 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/Persistence.js
+++ b/src/Persistence.js
@@ -0,0 +1,46 @@
+import { BinaryEncoder } from './Encoding.js'
+
+export default function extendPersistence (Y) {
+  class AbstractPersistence {
+    constructor (y, opts) {
+      this.y = y
+      this.opts = opts
+      this.saveOperationsBuffer = []
+      this.log = Y.debug('y:persistence')
+    }
+
+    saveToMessageQueue (binary) {
+      this.log('Room %s: Save message to message queue', this.y.options.connector.room)
+    }
+
+    saveOperations (ops) {
+      ops = ops.map(function (op) {
+        return Y.Struct[op.struct].encode(op)
+      })
+      const saveOperations = () => {
+        if (this.saveOperationsBuffer.length > 0) {
+          let encoder = new BinaryEncoder()
+          encoder.writeVarString(this.opts.room)
+          encoder.writeVarString('update')
+          let ops = this.saveOperationsBuffer
+          this.saveOperationsBuffer = []
+          let length = ops.length
+          encoder.writeUint32(length)
+          for (var i = 0; i < length; i++) {
+            let op = ops[i]
+            Y.Struct[op.struct].binaryEncode(encoder, op)
+          }
+          this.saveToMessageQueue(encoder.createBuffer())
+        }
+      }
+      if (this.saveOperationsBuffer.length === 0) {
+        this.saveOperationsBuffer = ops
+        this.y.db.whenTransactionsFinished().then(saveOperations)
+      } else {
+        this.saveOperationsBuffer = this.saveOperationsBuffer.concat(ops)
+      }
+    }
+  }
+
+  Y.AbstractPersistence = AbstractPersistence
+}
--- a/src/RedBlackTree.js
+++ b/src/RedBlackTree.js
@@ -0,0 +1,506 @@
+
+export default function extendRBTree (Y) {
+  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 this.findWithLowerBound([id[0], id[1] + 1])
+    }
+    findPrev (id) {
+      return 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
+          }
+        }
+      }
+    }
+    findSmallestNode () {
+      var o = this.root
+      while (o != null && o.left != null) {
+        o = o.left
+      }
+      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
+      if (from === null) {
+        o = this.findSmallestNode()
+      } else {
+        o = this.findNodeWithLowerBound(from)
+      }
+      while (
+        o !== null &&
+        (
+          to === null || // eslint-disable-line no-unmodified-loop-condition
+          Y.utils.smaller(o.val.id, to) ||
+          Y.utils.compareIds(o.val.id, to)
+        )
+      ) {
+        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 = []
+      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!')
+        return
+      }
+      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)
+        }
+      }
+    }
+    flush () {}
+  }
+
+  Y.utils.RBTree = RBTree
+}
--- a/src/Struct.js
+++ b/src/Struct.js
@@ -0,0 +1,619 @@
+const CDELETE = 0
+const CINSERT = 1
+const CLIST = 2
+const CMAP = 3
+const CXML = 4
+
+/*
+ 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.
+*/
+export default function extendStruct (Y) {
+  let Struct = {}
+  Y.Struct = Struct
+  Struct.binaryDecodeOperation = function (decoder) {
+    let code = decoder.peekUint8()
+    if (code === CDELETE) {
+      return Struct.Delete.binaryDecode(decoder)
+    } else if (code === CINSERT) {
+      return Struct.Insert.binaryDecode(decoder)
+    } else if (code === CLIST) {
+      return Struct.List.binaryDecode(decoder)
+    } else if (code === CMAP) {
+      return Struct.Map.binaryDecode(decoder)
+    } else if (code === CXML) {
+      return Struct.Xml.binaryDecode(decoder)
+    } else {
+      throw new Error('Unable to decode operation!')
+    }
+  }
+
+  /* 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
+  }
+  */
+  Struct.Delete = {
+    encode: function (op) {
+      return {
+        target: op.target,
+        length: op.length || 0,
+        struct: 'Delete'
+      }
+    },
+    binaryEncode: function (encoder, op) {
+      encoder.writeUint8(CDELETE)
+      encoder.writeOpID(op.target)
+      encoder.writeVarUint(op.length || 0)
+    },
+    binaryDecode: function (decoder) {
+      decoder.skip8()
+      return {
+        target: decoder.readOpID(),
+        length: decoder.readVarUint(),
+        struct: 'Delete'
+      }
+    },
+    requiredOps: function (op) {
+      return [] // [op.target]
+    },
+    execute: function (op) {
+      return this.deleteOperation(op.target, op.length || 1)
+    }
+  }
+
+  /* {
+      content: [any],
+      opContent: Id,
+      id: Id,
+      left: Id,
+      origin: Id,
+      right: Id,
+      parent: Id,
+      parentSub: string (optional), // child of Map type
+    }
+  */
+  Struct.Insert = {
+    encode: function (op/* :Insertion */) /* :Insertion */ {
+      // TODO: you could not send the "left" property, then you also have to
+      // "op.left = null" in $execute or $decode
+      var e/* :any */ = {
+        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.hasOwnProperty('opContent')) {
+        e.opContent = op.opContent
+      } else {
+        e.content = op.content.slice()
+      }
+
+      return e
+    },
+    binaryEncode: function (encoder, op) {
+      encoder.writeUint8(CINSERT)
+      // compute info property
+      let contentIsText = op.content != null && op.content.every(c => typeof c === 'string' && c.length === 1)
+      let originIsLeft = Y.utils.compareIds(op.left, op.origin)
+      let info =
+        (op.parentSub != null ? 1 : 0) |
+        (op.opContent != null ? 2 : 0) |
+        (contentIsText ? 4 : 0) |
+        (originIsLeft ? 8 : 0) |
+        (op.left != null ? 16 : 0) |
+        (op.right != null ? 32 : 0) |
+        (op.origin != null ? 64 : 0)
+      encoder.writeUint8(info)
+      encoder.writeOpID(op.id)
+      encoder.writeOpID(op.parent)
+      if (info & 16) {
+        encoder.writeOpID(op.left)
+      }
+      if (info & 32) {
+        encoder.writeOpID(op.right)
+      }
+      if (!originIsLeft && info & 64) {
+        encoder.writeOpID(op.origin)
+      }
+      if (info & 1) {
+        // write parentSub
+        encoder.writeVarString(op.parentSub)
+      }
+      if (info & 2) {
+        // write opContent
+        encoder.writeOpID(op.opContent)
+      } else if (info & 4) {
+        // write text
+        encoder.writeVarString(op.content.join(''))
+      } else {
+        // convert to JSON and write
+        encoder.writeVarString(JSON.stringify(op.content))
+      }
+    },
+    binaryDecode: function (decoder) {
+      let op = {
+        struct: 'Insert'
+      }
+      decoder.skip8()
+      // get info property
+      let info = decoder.readUint8()
+
+      op.id = decoder.readOpID()
+      op.parent = decoder.readOpID()
+      if (info & 16) {
+        op.left = decoder.readOpID()
+      } else {
+        op.left = null
+      }
+      if (info & 32) {
+        op.right = decoder.readOpID()
+      } else {
+        op.right = null
+      }
+      if (info & 8) {
+        // origin is left
+        op.origin = op.left
+      } else if (info & 64) {
+        op.origin = decoder.readOpID()
+      } else {
+        op.origin = null
+      }
+      if (info & 1) {
+        // has parentSub
+        op.parentSub = decoder.readVarString()
+      }
+      if (info & 2) {
+        // has opContent
+        op.opContent = decoder.readOpID()
+      } else if (info & 4) {
+        // has pure text content
+        op.content = decoder.readVarString().split('')
+      } else {
+        // has mixed content
+        let s = decoder.readVarString()
+        op.content = JSON.parse(s)
+      }
+      return op
+    },
+    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 = this.getInsertion(op.left)
+        while (!Y.utils.matchesId(o, op.origin)) {
+          d++
+          if (o.left == null) {
+            break
+          } else {
+            o = this.getInsertion(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
+
+      // during this function some ops may get split into two pieces (e.g. with getInsertionCleanEnd)
+      // We try to merge them later, if possible
+      var tryToRemergeLater = []
+
+      if (op.origin != null) { // TODO: !== instead of !=
+        // we save in origin that op originates in it
+        // we need that later when we eventually garbage collect origin (see transaction)
+        var origin = this.getInsertionCleanEnd(op.origin)
+        if (origin.originOf == null) {
+          origin.originOf = []
+        }
+        origin.originOf.push(op.id)
+        this.setOperation(origin)
+        if (origin.right != null) {
+          tryToRemergeLater.push(origin.right)
+        }
+      }
+      var distanceToOrigin = i = Struct.Insert.getDistanceToOrigin.call(this, op) // most cases: 0 (starts from 0)
+
+      // now we begin to insert op in the list of insertions..
+      var o
+      var parent
+      var start
+
+      // find o. o is the first conflicting operation
+      if (op.left != null) {
+        o = this.getInsertionCleanEnd(op.left)
+        if (!Y.utils.compareIds(op.left, op.origin) && o.right != null) {
+          // only if not added previously
+          tryToRemergeLater.push(o.right)
+        }
+        o = (o.right == null) ? null : this.getOperation(o.right)
+      } else { // left == null
+        parent = this.getOperation(op.parent)
+        let startId = op.parentSub ? parent.map[op.parentSub] : parent.start
+        start = startId == null ? null : this.getOperation(startId)
+        o = start
+      }
+
+      // make sure to split op.right if necessary (also add to tryCombineWithLeft)
+      if (op.right != null) {
+        tryToRemergeLater.push(op.right)
+        this.getInsertionCleanStart(op.right)
+      }
+
+      // handle conflicts
+      while (true) {
+        if (o != null && !Y.utils.compareIds(o.id, op.right)) {
+          var oOriginDistance = Struct.Insert.getDistanceToOrigin.call(this, o)
+          if (oOriginDistance === i) {
+            // case 1
+            if (o.id[0] < op.id[0]) {
+              op.left = Y.utils.getLastId(o)
+              distanceToOrigin = i + 1 // just ignore o.content.length, doesn't make a difference
+            }
+          } else if (oOriginDistance < i) {
+            // case 2
+            if (i - distanceToOrigin <= oOriginDistance) {
+              op.left = Y.utils.getLastId(o)
+              distanceToOrigin = i + 1 // just ignore o.content.length, doesn't make a difference
+            }
+          } else {
+            break
+          }
+          i++
+          if (o.right != null) {
+            o = this.getInsertion(o.right)
+          } else {
+            o = null
+          }
+        } else {
+          break
+        }
+      }
+
+      // reconnect..
+      var left = null
+      var right = null
+      if (parent == null) {
+        parent = this.getOperation(op.parent)
+      }
+
+      // reconnect left and set right of op
+      if (op.left != null) {
+        left = this.getInsertion(op.left)
+        // link left
+        op.right = left.right
+        left.right = op.id
+
+        this.setOperation(left)
+      } else {
+        // set op.right from parent, if necessary
+        op.right = op.parentSub ? parent.map[op.parentSub] || null : parent.start
+      }
+      // reconnect right
+      if (op.right != null) {
+        // TODO: wanna connect right too?
+        right = this.getOperation(op.right)
+        right.left = Y.utils.getLastId(op)
+
+        // if right exists, and it is supposed to be gc'd. Remove it from the gc
+        if (right.gc != null) {
+          if (right.content != null && right.content.length > 1) {
+            right = this.getInsertionCleanEnd(right.id)
+          }
+          this.store.removeFromGarbageCollector(right)
+        }
+        this.setOperation(right)
+      }
+
+      // update parents .map/start/end properties
+      if (op.parentSub != null) {
+        if (left == null) {
+          parent.map[op.parentSub] = op.id
+          this.setOperation(parent)
+        }
+        // is a child of a map struct.
+        // Then also make sure that only the most left element is not deleted
+        // We do not call the type in this case (this is what the third parameter is for)
+        if (op.right != null) {
+          this.deleteOperation(op.right, 1, true)
+        }
+        if (op.left != null) {
+          this.deleteOperation(op.id, 1, true)
+        }
+      } else {
+        if (right == null || left == null) {
+          if (right == null) {
+            parent.end = Y.utils.getLastId(op)
+          }
+          if (left == null) {
+            parent.start = op.id
+          }
+          this.setOperation(parent)
+        }
+      }
+
+      // try to merge original op.left and op.origin
+      for (i = 0; i < tryToRemergeLater.length; i++) {
+        var m = this.getOperation(tryToRemergeLater[i])
+        this.tryCombineWithLeft(m)
+      }
+    }
+  }
+
+  /*
+  {
+    start: null,
+    end: null,
+    struct: "List",
+    type: "",
+    id: this.os.getNextOpId(1)
+  }
+  */
+  Struct.List = {
+    create: function (id) {
+      return {
+        start: null,
+        end: null,
+        struct: 'List',
+        id: id
+      }
+    },
+    encode: function (op) {
+      var e = {
+        struct: 'List',
+        id: op.id,
+        type: op.type
+      }
+      return e
+    },
+    binaryEncode: function (encoder, op) {
+      encoder.writeUint8(CLIST)
+      encoder.writeOpID(op.id)
+      encoder.writeVarString(op.type)
+    },
+    binaryDecode: function (decoder) {
+      decoder.skip8()
+      let op = {
+        id: decoder.readOpID(),
+        type: decoder.readVarString(),
+        struct: 'List',
+        start: null,
+        end: null
+      }
+      return op
+    },
+    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 = this.getOperation(op.start)
+
+      while (true) {
+        if (!o.deleted) {
+          res = o
+          pos--
+        }
+        if (pos >= 0 && o.right != null) {
+          o = 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 = this.getOperation(o)
+        if (!operation.deleted) {
+          res.push(f(operation))
+        }
+        o = operation.right
+      }
+      return res
+    }
+  }
+
+  /*
+    {
+      map: {},
+      struct: "Map",
+      type: "",
+      id: this.os.getNextOpId(1)
+    }
+  */
+  Struct.Map = {
+    create: function (id) {
+      return {
+        id: id,
+        map: {},
+        struct: 'Map'
+      }
+    },
+    encode: function (op) {
+      var e = {
+        struct: 'Map',
+        type: op.type,
+        id: op.id,
+        map: {} // overwrite map!!
+      }
+      return e
+    },
+    binaryEncode: function (encoder, op) {
+      encoder.writeUint8(CMAP)
+      encoder.writeOpID(op.id)
+      encoder.writeVarString(op.type)
+    },
+    binaryDecode: function (decoder) {
+      decoder.skip8()
+      let op = {
+        id: decoder.readOpID(),
+        type: decoder.readVarString(),
+        struct: 'Map',
+        map: {}
+      }
+      return op
+    },
+    requiredOps: function () {
+      return []
+    },
+    execute: function (op) {
+      op.start = null
+      op.end = null
+    },
+    /*
+      Get a property by name
+    */
+    get: function (op, name) {
+      var oid = op.map[name]
+      if (oid != null) {
+        var res = this.getOperation(oid)
+        if (res == null || res.deleted) {
+          return void 0
+        } else if (res.opContent == null) {
+          return res.content[0]
+        } else {
+          return this.getType(res.opContent)
+        }
+      }
+    }
+  }
+
+  /*
+    {
+      map: {},
+      start: null,
+      end: null,
+      struct: "Xml",
+      type: "",
+      id: this.os.getNextOpId(1)
+    }
+  */
+  Struct.Xml = {
+    create: function (id, args) {
+      let nodeName = args != null ? args.nodeName : null
+      return {
+        id: id,
+        map: {},
+        start: null,
+        end: null,
+        struct: 'Xml',
+        nodeName
+      }
+    },
+    encode: function (op) {
+      var e = {
+        struct: 'Xml',
+        type: op.type,
+        id: op.id,
+        map: {},
+        nodeName: op.nodeName
+      }
+      return e
+    },
+    binaryEncode: function (encoder, op) {
+      encoder.writeUint8(CXML)
+      encoder.writeOpID(op.id)
+      encoder.writeVarString(op.type)
+      encoder.writeVarString(op.nodeName)
+    },
+    binaryDecode: function (decoder) {
+      decoder.skip8()
+      let op = {
+        id: decoder.readOpID(),
+        type: decoder.readVarString(),
+        struct: 'Xml',
+        map: {},
+        start: null,
+        end: null,
+        nodeName: decoder.readVarString()
+      }
+      return op
+    },
+    requiredOps: function () {
+      return []
+    },
+    execute: function () {},
+    ref: Struct.List.ref,
+    map: Struct.List.map,
+    /*
+      Get a property by name
+    */
+    get: Struct.Map.get
+  }
+}
--- a/src/Transaction.js
+++ b/src/Transaction.js
--- a/src/Utils.js
+++ b/src/Utils.js
@@ -0,0 +1,935 @@
+/* globals crypto */
+
+import { BinaryDecoder, BinaryEncoder } from './Encoding.js'
+
+/*
+  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"
+  ```
+  versus
+  ``` 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 helps you to make your type
+  synchronous.
+*/
+
+export default function Utils (Y) {
+  Y.utils = {
+    BinaryDecoder: BinaryDecoder,
+    BinaryEncoder: BinaryEncoder
+  }
+
+  Y.utils.bubbleEvent = function (type, event) {
+    type.eventHandler.callEventListeners(event)
+    event.path = []
+    while (type != null && type._deepEventHandler != null) {
+      type._deepEventHandler.callEventListeners(event)
+      var parent = null
+      if (type._parent != null) {
+        parent = type.os.getType(type._parent)
+      }
+      if (parent != null && parent._getPathToChild != null) {
+        event.path = [parent._getPathToChild(type._model)].concat(event.path)
+        type = parent
+      } else {
+        type = null
+      }
+    }
+  }
+
+  Y.utils.getRelativePosition = function (type, offset) {
+    if (type == null) {
+      return null
+    } else {
+      if (type._content.length <= offset) {
+        return ['endof', type._model[0], type._model[1]]
+      } else {
+        return type._content[offset].id
+      }
+    }
+  }
+
+  Y.utils.fromRelativePosition = function (y, id) {
+    var offset = 0
+    var op
+    if (id[0] === 'endof') {
+      id = y.db.os.find(id.slice(1)).end
+      op = y.db.os.findNodeWithUpperBound(id).val
+      if (!op.deleted) {
+        offset = op.content != null ? op.content.length : 1
+      }
+    } else {
+      op = y.db.os.findNodeWithUpperBound(id).val
+      if (!op.deleted) {
+        offset = id[1] - op.id[1]
+      }
+    }
+
+    var type = y.db.getType(op.parent)
+    if (type == null || y.db.os.find(op.parent).deleted) {
+      return null
+    }
+
+    while (op.left != null) {
+      op = y.db.os.findNodeWithUpperBound(op.left).val
+      if (!op.deleted) {
+        offset += op.content != null ? op.content.length : 1
+      }
+    }
+    return {
+      type: type,
+      offset: offset
+    }
+  }
+
+  class NamedEventHandler {
+    constructor () {
+      this._eventListener = {}
+    }
+    on (name, f) {
+      if (this._eventListener[name] == null) {
+        this._eventListener[name] = []
+      }
+      this._eventListener[name].push(f)
+    }
+    off (name, f) {
+      if (name == null || f == null) {
+        throw new Error('You must specify event name and function!')
+      }
+      let listener = this._eventListener[name] || []
+      this._eventListener[name] = listener.filter(e => e !== f)
+    }
+    emit (name, value) {
+      let listener = this._eventListener[name] || []
+      if (name === 'error' && listener.length === 0) {
+        console.error(value)
+      }
+      listener.forEach(l => l(value))
+    }
+    destroy () {
+      this._eventListener = null
+    }
+  }
+  Y.utils.NamedEventHandler = NamedEventHandler
+
+  class EventListenerHandler {
+    constructor () {
+      this.eventListeners = []
+    }
+    destroy () {
+      this.eventListeners = null
+    }
+     /*
+      Basic event listener boilerplate...
+    */
+    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 = 0; i < this.eventListeners.length; i++) {
+        try {
+          var _event = {}
+          for (var name in event) {
+            _event[name] = event[name]
+          }
+          this.eventListeners[i](_event)
+        } catch (e) {
+          /*
+            Your observer threw an error. This error was caught so that Yjs
+            can ensure data consistency! In order to debug this error you
+            have to check "Pause On Caught Exceptions" in developer tools.
+          */
+          console.error(e)
+        }
+      }
+    }
+  }
+  Y.utils.EventListenerHandler = EventListenerHandler
+
+  class EventHandler extends EventListenerHandler {
+    /* ::
+    waiting: Array<Insertion | Deletion>;
+    awaiting: number;
+    onevent: Function;
+    eventListeners: Array<Function>;
+    */
+    /*
+      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 /* : Function */) {
+      super()
+      this.waiting = []
+      this.awaiting = 0
+      this.onevent = onevent
+    }
+    destroy () {
+      super.destroy()
+      this.waiting = null
+      this.onevent = null
+    }
+    /*
+      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 if (op.struct === 'Delete') {
+        var self = this
+        var checkDelete = function checkDelete (d) {
+          if (d.length == null) {
+            throw new Error('This shouldn\'t happen! d.length must be defined!')
+          }
+          // we check if o deletes something in self.waiting
+          // if so, we remove the deleted operation
+          for (var w = 0; w < self.waiting.length; w++) {
+            var i = self.waiting[w]
+            if (i.struct === 'Insert' && i.id[0] === d.target[0]) {
+              var iLength = i.hasOwnProperty('content') ? i.content.length : 1
+              var dStart = d.target[1]
+              var dEnd = d.target[1] + (d.length || 1)
+              var iStart = i.id[1]
+              var iEnd = i.id[1] + iLength
+              // Check if they don't overlap
+              if (iEnd <= dStart || dEnd <= iStart) {
+                // no overlapping
+                continue
+              }
+              // we check all overlapping cases. All cases:
+              /*
+                1)  iiiii
+                      ddddd
+                    --> modify i and d
+                2)  iiiiiii
+                      ddddd
+                    --> modify i, remove d
+                3)  iiiiiii
+                      ddd
+                    --> remove d, modify i, and create another i (for the right hand side)
+                4)  iiiii
+                    ddddddd
+                    --> remove i, modify d
+                5)  iiiiiii
+                    ddddddd
+                    --> remove both i and d (**)
+                6)  iiiiiii
+                    ddddd
+                    --> modify i, remove d
+                7)    iii
+                    ddddddd
+                    --> remove i, create and apply two d with checkDelete(d) (**)
+                8)    iiiii
+                    ddddddd
+                    --> remove i, modify d (**)
+                9)    iiiii
+                    ddddd
+                    --> modify i and d
+                (**) (also check if i contains content or type)
+              */
+              // TODO: I left some debugger statements, because I want to debug all cases once in production. REMEMBER END TODO
+              if (iStart < dStart) {
+                if (dStart < iEnd) {
+                  if (iEnd < dEnd) {
+                    // Case 1
+                    // remove the right part of i's content
+                    i.content.splice(dStart - iStart)
+                    // remove the start of d's deletion
+                    d.length = dEnd - iEnd
+                    d.target = [d.target[0], iEnd]
+                    continue
+                  } else if (iEnd === dEnd) {
+                    // Case 2
+                    i.content.splice(dStart - iStart)
+                    // remove d, we do that by simply ending this function
+                    return
+                  } else { // (dEnd < iEnd)
+                    // Case 3
+                    var newI = {
+                      id: [i.id[0], dEnd],
+                      content: i.content.slice(dEnd - iStart),
+                      struct: 'Insert'
+                    }
+                    self.waiting.push(newI)
+                    i.content.splice(dStart - iStart)
+                    return
+                  }
+                }
+              } else if (dStart === iStart) {
+                if (iEnd < dEnd) {
+                  // Case 4
+                  d.length = dEnd - iEnd
+                  d.target = [d.target[0], iEnd]
+                  i.content = []
+                  continue
+                } else if (iEnd === dEnd) {
+                  // Case 5
+                  self.waiting.splice(w, 1)
+                  return
+                } else { // (dEnd < iEnd)
+                  // Case 6
+                  i.content = i.content.slice(dEnd - iStart)
+                  i.id = [i.id[0], dEnd]
+                  return
+                }
+              } else { // (dStart < iStart)
+                if (iStart < dEnd) {
+                  // they overlap
+                  /*
+                  7)    iii
+                      ddddddd
+                      --> remove i, create and apply two d with checkDelete(d) (**)
+                  8)    iiiii
+                      ddddddd
+                      --> remove i, modify d (**)
+                  9)    iiiii
+                      ddddd
+                      --> modify i and d
+                  */
+                  if (iEnd < dEnd) {
+                    // Case 7
+                    // debugger // TODO: You did not test this case yet!!!! (add the debugger here)
+                    self.waiting.splice(w, 1)
+                    checkDelete({
+                      target: [d.target[0], dStart],
+                      length: iStart - dStart,
+                      struct: 'Delete'
+                    })
+                    checkDelete({
+                      target: [d.target[0], iEnd],
+                      length: iEnd - dEnd,
+                      struct: 'Delete'
+                    })
+                    return
+                  } else if (iEnd === dEnd) {
+                    // Case 8
+                    self.waiting.splice(w, 1)
+                    w--
+                    d.length -= iLength
+                    continue
+                  } else { // dEnd < iEnd
+                    // Case 9
+                    d.length = iStart - dStart
+                    i.content.splice(0, dEnd - iStart)
+                    i.id = [i.id[0], dEnd]
+                    continue
+                  }
+                }
+              }
+            }
+          }
+          // finished with remaining operations
+          self.waiting.push(d)
+        }
+        if (op.key == null) {
+          // deletes in list
+          checkDelete(op)
+        } else {
+          // deletes in map
+          this.waiting.push(op)
+        }
+      } else {
+        this.waiting.push(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++
+      ops.map(Y.utils.copyOperation).forEach(this.onevent)
+    }
+    awaitOps (transaction, f, args) {
+      function notSoSmartSort (array) {
+        // this function sorts insertions in a executable order
+        var result = []
+        while (array.length > 0) {
+          for (var i = 0; i < array.length; i++) {
+            var independent = true
+            for (var j = 0; j < array.length; j++) {
+              if (Y.utils.matchesId(array[j], array[i].left)) {
+                // array[i] depends on array[j]
+                independent = false
+                break
+              }
+            }
+            if (independent) {
+              result.push(array.splice(i, 1)[0])
+              i--
+            }
+          }
+        }
+        return result
+      }
+      var before = this.waiting.length
+      // somehow create new operations
+      f.apply(transaction, args)
+      // remove all appended ops / awaited ops
+      this.waiting.splice(before)
+      if (this.awaiting > 0) this.awaiting--
+      // if there are no awaited ops anymore, we can update all waiting ops, and send execute them (if there are still no awaited ops)
+      if (this.awaiting === 0 && this.waiting.length > 0) {
+        // update all waiting ops
+        for (let i = 0; i < this.waiting.length; i++) {
+          var o = this.waiting[i]
+          if (o.struct === 'Insert') {
+            var _o = transaction.getInsertion(o.id)
+            if (_o.parentSub != null && _o.left != null) {
+              // if o is an insertion of a map struc (parentSub is defined), then it shouldn't be necessary to compute left
+              this.waiting.splice(i, 1)
+              i-- // update index
+            } else if (!Y.utils.compareIds(_o.id, o.id)) {
+              // o got extended
+              o.left = [o.id[0], o.id[1] - 1]
+            } else if (_o.left == null) {
+              o.left = null
+            } else {
+              // find next undeleted op
+              var left = transaction.getInsertion(_o.left)
+              while (left.deleted != null) {
+                if (left.left != null) {
+                  left = transaction.getInsertion(left.left)
+                } else {
+                  left = null
+                  break
+                }
+              }
+              o.left = left != null ? Y.utils.getLastId(left) : null
+            }
+          }
+        }
+        // the previous stuff was async, so we have to check again!
+        // We also pull changes from the bindings, if there exists such a method, this could increase awaiting too
+        if (this._pullChanges != null) {
+          this._pullChanges()
+        }
+        if (this.awaiting === 0) {
+          // sort by type, execute inserts first
+          var ins = []
+          var dels = []
+          this.waiting.forEach(function (o) {
+            if (o.struct === 'Delete') {
+              dels.push(o)
+            } else {
+              ins.push(o)
+            }
+          })
+          this.waiting = []
+          // put in executable order
+          ins = notSoSmartSort(ins)
+          // this.onevent can trigger the creation of another operation
+          // -> check if this.awaiting increased & stop computation if it does
+          for (var i = 0; i < ins.length; i++) {
+            if (this.awaiting === 0) {
+              this.onevent(ins[i])
+            } else {
+              this.waiting = this.waiting.concat(ins.slice(i))
+              break
+            }
+          }
+          for (i = 0; i < dels.length; i++) {
+            if (this.awaiting === 0) {
+              this.onevent(dels[i])
+            } else {
+              this.waiting = this.waiting.concat(dels.slice(i))
+              break
+            }
+          }
+        }
+      }
+    }
+    // TODO: Remove awaitedInserts and awaitedDeletes in favor of awaitedOps, as they are deprecated and do not always work
+    // Do this in one of the coming releases that are breaking anyway
+    /*
+      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]
+        if (op.struct === 'Insert') {
+          for (var i = this.waiting.length - 1; i >= 0; i--) {
+            let w = this.waiting[i]
+            // TODO: do I handle split operations correctly here? Super unlikely, but yeah..
+            // Also: can this case happen? Can op be inserted in the middle of a larger op that is in $waiting?
+            if (w.struct === 'Insert') {
+              if (Y.utils.matchesId(w, op.left)) {
+                // 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(w.id, op.right)) {
+                // similar..
+                w.left = Y.utils.getLastId(op)
+                op.right = w.right
+              }
+            }
+          }
+        } else {
+          throw new Error('Expected Insert Operation!')
+        }
+      }
+      this._tryCallEvents(n)
+    }
+    /*
+      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 = 0; j < ops.length; j++) {
+        var del = ops[j]
+        if (del.struct === 'Delete') {
+          if (newLeft != null) {
+            for (var i = 0; i < this.waiting.length; i++) {
+              let w = this.waiting[i]
+              // We will just care about w.left
+              if (w.struct === 'Insert' && Y.utils.compareIds(del.target, w.left)) {
+                w.left = newLeft
+              }
+            }
+          }
+        } else {
+          throw new Error('Expected Delete Operation!')
+        }
+      }
+      this._tryCallEvents(n)
+    }
+    /* (private)
+      Try to execute the events for the waiting operations
+    */
+    _tryCallEvents () {
+      function notSoSmartSort (array) {
+        var result = []
+        while (array.length > 0) {
+          for (var i = 0; i < array.length; i++) {
+            var independent = true
+            for (var j = 0; j < array.length; j++) {
+              if (Y.utils.matchesId(array[j], array[i].left)) {
+                // array[i] depends on array[j]
+                independent = false
+                break
+              }
+            }
+            if (independent) {
+              result.push(array.splice(i, 1)[0])
+              i--
+            }
+          }
+        }
+        return result
+      }
+      if (this.awaiting > 0) this.awaiting--
+      if (this.awaiting === 0 && this.waiting.length > 0) {
+        var ins = []
+        var dels = []
+        this.waiting.forEach(function (o) {
+          if (o.struct === 'Delete') {
+            dels.push(o)
+          } else {
+            ins.push(o)
+          }
+        })
+        ins = notSoSmartSort(ins)
+        ins.forEach(this.onevent)
+        dels.forEach(this.onevent)
+        this.waiting = []
+      }
+    }
+  }
+  Y.utils.EventHandler = EventHandler
+
+  /*
+    Default class of custom types!
+  */
+  class CustomType {
+    getPath () {
+      var parent = null
+      if (this._parent != null) {
+        parent = this.os.getType(this._parent)
+      }
+      if (parent != null && parent._getPathToChild != null) {
+        var firstKey = parent._getPathToChild(this._model)
+        var parentKeys = parent.getPath()
+        parentKeys.push(firstKey)
+        return parentKeys
+      } else {
+        return []
+      }
+    }
+  }
+  Y.utils.CustomType = CustomType
+
+  /*
+    A wrapper for the definition of a custom type.
+    Every custom type must have three properties:
+
+    * struct
+      - Structname of this 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 CustomTypeDefinition { // eslint-disable-line
+    /* ::
+    struct: any;
+    initType: any;
+    class: Function;
+    name: String;
+    */
+    constructor (def) {
+      if (def.struct == null ||
+        def.initType == null ||
+        def.class == null ||
+        def.name == null ||
+        def.createType == null
+      ) {
+        throw new Error('Custom type was not initialized correctly!')
+      }
+      this.struct = def.struct
+      this.initType = def.initType
+      this.createType = def.createType
+      this.class = def.class
+      this.name = def.name
+      if (def.appendAdditionalInfo != null) {
+        this.appendAdditionalInfo = def.appendAdditionalInfo
+      }
+      this.parseArguments = (def.parseArguments || function () {
+        return [this]
+      }).bind(this)
+      this.parseArguments.typeDefinition = this
+    }
+  }
+  Y.utils.CustomTypeDefinition = CustomTypeDefinition
+
+  Y.utils.isTypeDefinition = function isTypeDefinition (v) {
+    if (v != null) {
+      if (v instanceof Y.utils.CustomTypeDefinition) return [v]
+      else if (v.constructor === Array && v[0] instanceof Y.utils.CustomTypeDefinition) return v
+      else if (v instanceof Function && v.typeDefinition instanceof Y.utils.CustomTypeDefinition) return [v.typeDefinition]
+    }
+    return false
+  }
+
+  /*
+    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
+
+  /*
+    Copy an operation, so that it can be manipulated.
+    Note: You must not change subproperties (except o.content)!
+  */
+  function copyOperation (o) {
+    o = copyObject(o)
+    if (o.content != null) {
+      o.content = o.content.map(function (c) { return c })
+    }
+    return o
+  }
+
+  Y.utils.copyOperation = copyOperation
+
+  /*
+    Defines a smaller relation on Id's
+  */
+  function smaller (a, b) {
+    return a[0] < b[0] || (a[0] === b[0] && (a[1] < b[1] || typeof a[1] < typeof b[1]))
+  }
+  Y.utils.smaller = smaller
+
+  function inDeletionRange (del, ins) {
+    return del.target[0] === ins[0] && del.target[1] <= ins[1] && ins[1] < del.target[1] + (del.length || 1)
+  }
+  Y.utils.inDeletionRange = inDeletionRange
+
+  function compareIds (id1, id2) {
+    if (id1 == null || id2 == null) {
+      return id1 === id2
+    } else {
+      return id1[0] === id2[0] && id1[1] === id2[1]
+    }
+  }
+  Y.utils.compareIds = compareIds
+
+  function matchesId (op, id) {
+    if (id == null || op == null) {
+      return id === op
+    } else {
+      if (id[0] === op.id[0]) {
+        if (op.content == null) {
+          return id[1] === op.id[1]
+        } else {
+          return id[1] >= op.id[1] && id[1] < op.id[1] + op.content.length
+        }
+      }
+    }
+    return false
+  }
+  Y.utils.matchesId = matchesId
+
+  function getLastId (op) {
+    if (op.content == null || op.content.length === 1) {
+      return op.id
+    } else {
+      return [op.id[0], op.id[1] + op.content.length - 1]
+    }
+  }
+  Y.utils.getLastId = getLastId
+
+  function createEmptyOpsArray (n) {
+    var a = new Array(n)
+    for (var i = 0; i < a.length; i++) {
+      a[i] = {
+        id: [null, null]
+      }
+    }
+    return a
+  }
+
+  function createSmallLookupBuffer (Store) {
+    /*
+      This buffer implements a very small buffer that temporarily stores operations
+      after they are read / before they are written.
+      The buffer basically implements FIFO. Often requested lookups will be re-queued every time they are looked up / written.
+
+      It can speed up lookups on Operation Stores and State Stores. But it does not require notable use of memory or processing power.
+
+      Good for os and ss, bot not for ds (because it often uses methods that require a flush)
+
+      I tried to optimize this for performance, therefore no highlevel operations.
+    */
+    class SmallLookupBuffer extends Store {
+      constructor (arg1, arg2) {
+        // super(...arguments) -- do this when this is supported by stable nodejs
+        super(arg1, arg2)
+        this.writeBuffer = createEmptyOpsArray(5)
+        this.readBuffer = createEmptyOpsArray(10)
+      }
+      find (id, noSuperCall) {
+        var i, r
+        for (i = this.readBuffer.length - 1; i >= 0; i--) {
+          r = this.readBuffer[i]
+          // we don't have to use compareids, because id is always defined!
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            // found r
+            // move r to the end of readBuffer
+            for (; i < this.readBuffer.length - 1; i++) {
+              this.readBuffer[i] = this.readBuffer[i + 1]
+            }
+            this.readBuffer[this.readBuffer.length - 1] = r
+            return r
+          }
+        }
+        var o
+        for (i = this.writeBuffer.length - 1; i >= 0; i--) {
+          r = this.writeBuffer[i]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            o = r
+            break
+          }
+        }
+        if (i < 0 && noSuperCall === undefined) {
+          // did not reach break in last loop
+          // read id and put it to the end of readBuffer
+          o = super.find(id)
+        }
+        if (o != null) {
+          for (i = 0; i < this.readBuffer.length - 1; i++) {
+            this.readBuffer[i] = this.readBuffer[i + 1]
+          }
+          this.readBuffer[this.readBuffer.length - 1] = o
+        }
+        return o
+      }
+      put (o) {
+        var id = o.id
+        var i, r // helper variables
+        for (i = this.writeBuffer.length - 1; i >= 0; i--) {
+          r = this.writeBuffer[i]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            // is already in buffer
+            // forget r, and move o to the end of writeBuffer
+            for (; i < this.writeBuffer.length - 1; i++) {
+              this.writeBuffer[i] = this.writeBuffer[i + 1]
+            }
+            this.writeBuffer[this.writeBuffer.length - 1] = o
+            break
+          }
+        }
+        if (i < 0) {
+          // did not reach break in last loop
+          // write writeBuffer[0]
+          var write = this.writeBuffer[0]
+          if (write.id[0] !== null) {
+            super.put(write)
+          }
+          // put o to the end of writeBuffer
+          for (i = 0; i < this.writeBuffer.length - 1; i++) {
+            this.writeBuffer[i] = this.writeBuffer[i + 1]
+          }
+          this.writeBuffer[this.writeBuffer.length - 1] = o
+        }
+        // check readBuffer for every occurence of o.id, overwrite if found
+        // whether found or not, we'll append o to the readbuffer
+        for (i = 0; i < this.readBuffer.length - 1; i++) {
+          r = this.readBuffer[i + 1]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            this.readBuffer[i] = o
+          } else {
+            this.readBuffer[i] = r
+          }
+        }
+        this.readBuffer[this.readBuffer.length - 1] = o
+      }
+      delete (id) {
+        var i, r
+        for (i = 0; i < this.readBuffer.length; i++) {
+          r = this.readBuffer[i]
+          if (r.id[1] === id[1] && r.id[0] === id[0]) {
+            this.readBuffer[i] = {
+              id: [null, null]
+            }
+          }
+        }
+        this.flush()
+        super.delete(id)
+      }
+      findWithLowerBound (id) {
+        var o = this.find(id, true)
+        if (o != null) {
+          return o
+        } else {
+          this.flush()
+          return super.findWithLowerBound.apply(this, arguments)
+        }
+      }
+      findWithUpperBound (id) {
+        var o = this.find(id, true)
+        if (o != null) {
+          return o
+        } else {
+          this.flush()
+          return super.findWithUpperBound.apply(this, arguments)
+        }
+      }
+      findNext () {
+        this.flush()
+        return super.findNext.apply(this, arguments)
+      }
+      findPrev () {
+        this.flush()
+        return super.findPrev.apply(this, arguments)
+      }
+      iterate () {
+        this.flush()
+        super.iterate.apply(this, arguments)
+      }
+      flush () {
+        for (var i = 0; i < this.writeBuffer.length; i++) {
+          var write = this.writeBuffer[i]
+          if (write.id[0] !== null) {
+            super.put(write)
+            this.writeBuffer[i] = {
+              id: [null, null]
+            }
+          }
+        }
+      }
+    }
+    return SmallLookupBuffer
+  }
+  Y.utils.createSmallLookupBuffer = createSmallLookupBuffer
+
+  function generateUserId () {
+    if (typeof crypto !== 'undefined' && crypto.getRandomValue != null) {
+      // browser
+      let arr = new Uint32Array(1)
+      crypto.getRandomValues(arr)
+      return arr[0]
+    } else if (typeof crypto !== 'undefined' && crypto.randomBytes != null) {
+      // node
+      let buf = crypto.randomBytes(4)
+      return new Uint32Array(buf.buffer)[0]
+    } else {
+      return Math.ceil(Math.random() * 0xFFFFFFFF)
+    }
+  }
+  Y.utils.generateUserId = generateUserId
+
+  Y.utils.parseTypeDefinition = function parseTypeDefinition (type, typeArgs) {
+    var args = []
+    try {
+      args = JSON.parse('[' + typeArgs + ']')
+    } catch (e) {
+      throw new Error('Was not able to parse type definition!')
+    }
+    if (type.typeDefinition.parseArguments != null) {
+      args = type.typeDefinition.parseArguments(args[0])[1]
+    }
+    return args
+  }
+
+  Y.utils.writeObjectToYMap = function writeObjectToYMap (object, type) {
+    for (var key in object) {
+      var val = object[key]
+      if (Array.isArray(val)) {
+        type.set(key, Y.Array)
+        Y.utils.writeArrayToYArray(val, type.get(key))
+      } else if (typeof val === 'object') {
+        type.set(key, Y.Map)
+        Y.utils.writeObjectToYMap(val, type.get(key))
+      } else {
+        type.set(key, val)
+      }
+    }
+  }
+
+  Y.utils.writeArrayToYArray = function writeArrayToYArray (array, type) {
+    for (var i = array.length - 1; i >= 0; i--) {
+      var val = array[i]
+      if (Array.isArray(val)) {
+        type.insert(0, [Y.Array])
+        Y.utils.writeArrayToYArray(val, type.get(0))
+      } else if (typeof val === 'object') {
+        type.insert(0, [Y.Map])
+        Y.utils.writeObjectToYMap(val, type.get(0))
+      } else {
+        type.insert(0, [val])
+      }
+    }
+  }
+}
--- a/src/index.js
+++ b/src/index.js
@@ -1,74 +0,0 @@
-
-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,
-  YTextEvent,
-  YEvent,
-  Item,
-  AbstractStruct,
-  GC,
-  ContentBinary,
-  ContentDeleted,
-  ContentEmbed,
-  ContentFormat,
-  ContentJSON,
-  ContentAny,
-  ContentString,
-  ContentType,
-  AbstractType,
-  RelativePosition,
-  getTypeChildren,
-  createRelativePositionFromTypeIndex,
-  createRelativePositionFromJSON,
-  createAbsolutePositionFromRelativePosition,
-  compareRelativePositions,
-  writeRelativePosition,
-  readRelativePosition,
-  ID,
-  createID,
-  compareIDs,
-  getState,
-  Snapshot,
-  createSnapshot,
-  createDeleteSet,
-  createDeleteSetFromStructStore,
-  snapshot,
-  emptySnapshot,
-  findRootTypeKey,
-  typeListToArraySnapshot,
-  typeMapGetSnapshot,
-  iterateDeletedStructs,
-  applyUpdate,
-  applyUpdateV2,
-  readUpdate,
-  readUpdateV2,
-  encodeStateAsUpdate,
-  encodeStateAsUpdateV2,
-  encodeStateVector,
-  encodeStateVectorV2,
-  UndoManager,
-  decodeSnapshot,
-  encodeSnapshot,
-  decodeSnapshotV2,
-  encodeSnapshotV2,
-  decodeStateVector,
-  decodeStateVectorV2,
-  isDeleted,
-  isParentOf,
-  equalSnapshots,
-  PermanentUserData, // @TODO experimental
-  tryGc,
-  transact,
-  AbstractConnector,
-  logType
-} from './internals.js'
--- a/src/internals.js
+++ b/src/internals.js
@@ -1,40 +0,0 @@
-
-export * from './utils/AbstractConnector.js'
-export * from './utils/DeleteSet.js'
-export * from './utils/Doc.js'
-export * from './utils/UpdateDecoder.js'
-export * from './utils/UpdateEncoder.js'
-export * from './utils/encoding.js'
-export * from './utils/EventHandler.js'
-export * from './utils/ID.js'
-export * from './utils/isParentOf.js'
-export * from './utils/logging.js'
-export * from './utils/PermanentUserData.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/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/GC.js'
-export * from './structs/ContentBinary.js'
-export * from './structs/ContentDeleted.js'
-export * from './structs/ContentEmbed.js'
-export * from './structs/ContentFormat.js'
-export * from './structs/ContentJSON.js'
-export * from './structs/ContentAny.js'
-export * from './structs/ContentString.js'
-export * from './structs/ContentType.js'
-export * from './structs/Item.js'
--- a/src/structs/AbstractStruct.js
+++ b/src/structs/AbstractStruct.js
@@ -1,52 +0,0 @@
-
-import {
-  AbstractUpdateEncoder, ID, Transaction // eslint-disable-line
-} from '../internals.js'
-
-import * as error from 'lib0/error.js'
-
-export class AbstractStruct {
-  /**
-   * @param {ID} id
-   * @param {number} length
-   */
-  constructor (id, length) {
-    this.id = id
-    this.length = length
-  }
-
-  /**
-   * @type {boolean}
-   */
-  get deleted () {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * 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
-  }
-
-  /**
-   * @param {AbstractUpdateEncoder} encoder The encoder to write data to.
-   * @param {number} offset
-   * @param {number} encodingRef
-   */
-  write (encoder, offset, encodingRef) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {number} offset
-   */
-  integrate (transaction, offset) {
-    throw error.methodUnimplemented()
-  }
-}
--- a/src/structs/ContentAny.js
+++ b/src/structs/ContentAny.js
@@ -1,108 +0,0 @@
-import {
-  AbstractUpdateDecoder, AbstractUpdateEncoder, Transaction, Item, StructStore // eslint-disable-line
-} from '../internals.js'
-
-export class ContentAny {
-  /**
-   * @param {Array<any>} arr
-   */
-  constructor (arr) {
-    /**
-     * @type {Array<any>}
-     */
-    this.arr = arr
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return this.arr.length
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return this.arr
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return true
-  }
-
-  /**
-   * @return {ContentAny}
-   */
-  copy () {
-    return new ContentAny(this.arr)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentAny}
-   */
-  splice (offset) {
-    const right = new ContentAny(this.arr.slice(offset))
-    this.arr = this.arr.slice(0, offset)
-    return right
-  }
-
-  /**
-   * @param {ContentAny} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    this.arr = this.arr.concat(right.arr)
-    return true
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {}
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    const len = this.arr.length
-    encoder.writeLen(len - offset)
-    for (let i = offset; i < len; i++) {
-      const c = this.arr[i]
-      encoder.writeAny(c)
-    }
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 8
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentAny}
- */
-export const readContentAny = decoder => {
-  const len = decoder.readLen()
-  const cs = []
-  for (let i = 0; i < len; i++) {
-    cs.push(decoder.readAny())
-  }
-  return new ContentAny(cs)
-}
--- a/src/structs/ContentBinary.js
+++ b/src/structs/ContentBinary.js
@@ -1,92 +0,0 @@
-import {
-  AbstractUpdateDecoder, AbstractUpdateEncoder, StructStore, Item, Transaction // eslint-disable-line
-} from '../internals.js'
-
-import * as error from 'lib0/error.js'
-
-export class ContentBinary {
-  /**
-   * @param {Uint8Array} content
-   */
-  constructor (content) {
-    this.content = content
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return 1
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return [this.content]
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return true
-  }
-
-  /**
-   * @return {ContentBinary}
-   */
-  copy () {
-    return new ContentBinary(this.content)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentBinary}
-   */
-  splice (offset) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {ContentBinary} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    return false
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {}
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    encoder.writeBuf(this.content)
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 3
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentBinary}
- */
-export const readContentBinary = decoder => new ContentBinary(decoder.readBuf())
--- a/src/structs/ContentDeleted.js
+++ b/src/structs/ContentDeleted.js
@@ -1,101 +0,0 @@
-
-import {
-  addToDeleteSet,
-  AbstractUpdateDecoder, AbstractUpdateEncoder, StructStore, Item, Transaction // eslint-disable-line
-} from '../internals.js'
-
-export class ContentDeleted {
-  /**
-   * @param {number} len
-   */
-  constructor (len) {
-    this.len = len
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return this.len
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return []
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return false
-  }
-
-  /**
-   * @return {ContentDeleted}
-   */
-  copy () {
-    return new ContentDeleted(this.len)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentDeleted}
-   */
-  splice (offset) {
-    const right = new ContentDeleted(this.len - offset)
-    this.len = offset
-    return right
-  }
-
-  /**
-   * @param {ContentDeleted} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    this.len += right.len
-    return true
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {
-    addToDeleteSet(transaction.deleteSet, item.id.client, item.id.clock, this.len)
-    item.markDeleted()
-  }
-
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    encoder.writeLen(this.len - offset)
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 1
-  }
-}
-
-/**
- * @private
- *
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentDeleted}
- */
-export const readContentDeleted = decoder => new ContentDeleted(decoder.readLen())
--- a/src/structs/ContentEmbed.js
+++ b/src/structs/ContentEmbed.js
@@ -1,98 +0,0 @@
-
-import {
-  AbstractUpdateDecoder, AbstractUpdateEncoder, StructStore, Item, Transaction // eslint-disable-line
-} from '../internals.js'
-
-import * as error from 'lib0/error.js'
-
-/**
- * @private
- */
-export class ContentEmbed {
-  /**
-   * @param {Object} embed
-   */
-  constructor (embed) {
-    this.embed = embed
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return 1
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return [this.embed]
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return true
-  }
-
-  /**
-   * @return {ContentEmbed}
-   */
-  copy () {
-    return new ContentEmbed(this.embed)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentEmbed}
-   */
-  splice (offset) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {ContentEmbed} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    return false
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {}
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    encoder.writeJSON(this.embed)
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 5
-  }
-}
-
-/**
- * @private
- *
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentEmbed}
- */
-export const readContentEmbed = decoder => new ContentEmbed(decoder.readJSON())
--- a/src/structs/ContentFormat.js
+++ b/src/structs/ContentFormat.js
@@ -1,103 +0,0 @@
-
-import {
-  AbstractType, AbstractUpdateDecoder, AbstractUpdateEncoder, Item, StructStore, Transaction // eslint-disable-line
-} from '../internals.js'
-
-import * as error from 'lib0/error.js'
-
-/**
- * @private
- */
-export class ContentFormat {
-  /**
-   * @param {string} key
-   * @param {Object} value
-   */
-  constructor (key, value) {
-    this.key = key
-    this.value = value
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return 1
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return []
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return false
-  }
-
-  /**
-   * @return {ContentFormat}
-   */
-  copy () {
-    return new ContentFormat(this.key, this.value)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentFormat}
-   */
-  splice (offset) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {ContentFormat} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    return false
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {
-    // @todo searchmarker are currently unsupported for rich text documents
-    /** @type {AbstractType<any>} */ (item.parent)._searchMarker = null
-  }
-
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    encoder.writeKey(this.key)
-    encoder.writeJSON(this.value)
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 6
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentFormat}
- */
-export const readContentFormat = decoder => new ContentFormat(decoder.readString(), decoder.readJSON())
--- a/src/structs/ContentJSON.js
+++ b/src/structs/ContentJSON.js
@@ -1,118 +0,0 @@
-import {
-  AbstractUpdateDecoder, AbstractUpdateEncoder, Transaction, Item, StructStore // eslint-disable-line
-} from '../internals.js'
-
-/**
- * @private
- */
-export class ContentJSON {
-  /**
-   * @param {Array<any>} arr
-   */
-  constructor (arr) {
-    /**
-     * @type {Array<any>}
-     */
-    this.arr = arr
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return this.arr.length
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return this.arr
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return true
-  }
-
-  /**
-   * @return {ContentJSON}
-   */
-  copy () {
-    return new ContentJSON(this.arr)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentJSON}
-   */
-  splice (offset) {
-    const right = new ContentJSON(this.arr.slice(offset))
-    this.arr = this.arr.slice(0, offset)
-    return right
-  }
-
-  /**
-   * @param {ContentJSON} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    this.arr = this.arr.concat(right.arr)
-    return true
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {}
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    const len = this.arr.length
-    encoder.writeLen(len - offset)
-    for (let i = offset; i < len; i++) {
-      const c = this.arr[i]
-      encoder.writeString(c === undefined ? 'undefined' : JSON.stringify(c))
-    }
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 2
-  }
-}
-
-/**
- * @private
- *
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentJSON}
- */
-export const readContentJSON = decoder => {
-  const len = decoder.readLen()
-  const cs = []
-  for (let i = 0; i < len; i++) {
-    const c = decoder.readString()
-    if (c === 'undefined') {
-      cs.push(undefined)
-    } else {
-      cs.push(JSON.parse(c))
-    }
-  }
-  return new ContentJSON(cs)
-}
--- a/src/structs/ContentString.js
+++ b/src/structs/ContentString.js
@@ -1,101 +0,0 @@
-import {
-  AbstractUpdateDecoder, AbstractUpdateEncoder, Transaction, Item, StructStore // eslint-disable-line
-} from '../internals.js'
-
-/**
- * @private
- */
-export class ContentString {
-  /**
-   * @param {string} str
-   */
-  constructor (str) {
-    /**
-     * @type {string}
-     */
-    this.str = str
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return this.str.length
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return this.str.split('')
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return true
-  }
-
-  /**
-   * @return {ContentString}
-   */
-  copy () {
-    return new ContentString(this.str)
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentString}
-   */
-  splice (offset) {
-    const right = new ContentString(this.str.slice(offset))
-    this.str = this.str.slice(0, offset)
-    return right
-  }
-
-  /**
-   * @param {ContentString} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    this.str += right.str
-    return true
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {}
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {}
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {}
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    encoder.writeString(offset === 0 ? this.str : this.str.slice(offset))
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 4
-  }
-}
-
-/**
- * @private
- *
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentString}
- */
-export const readContentString = decoder => new ContentString(decoder.readString())
--- a/src/structs/ContentType.js
+++ b/src/structs/ContentType.js
@@ -1,172 +0,0 @@
-
-import {
-  readYArray,
-  readYMap,
-  readYText,
-  readYXmlElement,
-  readYXmlFragment,
-  readYXmlHook,
-  readYXmlText,
-  AbstractUpdateDecoder, AbstractUpdateEncoder, StructStore, Transaction, Item, YEvent, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as error from 'lib0/error.js'
-
-/**
- * @type {Array<function(AbstractUpdateDecoder):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 ContentType {
-  /**
-   * @param {AbstractType<YEvent>} type
-   */
-  constructor (type) {
-    /**
-     * @type {AbstractType<any>}
-     */
-    this.type = type
-  }
-
-  /**
-   * @return {number}
-   */
-  getLength () {
-    return 1
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    return [this.type]
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isCountable () {
-    return true
-  }
-
-  /**
-   * @return {ContentType}
-   */
-  copy () {
-    return new ContentType(this.type._copy())
-  }
-
-  /**
-   * @param {number} offset
-   * @return {ContentType}
-   */
-  splice (offset) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {ContentType} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    return false
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {
-    this.type._integrate(transaction.doc, item)
-  }
-
-  /**
-   * @param {Transaction} transaction
-   */
-  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.push(item)
-      }
-      item = item.right
-    }
-    this.type._map.forEach(item => {
-      if (!item.deleted) {
-        item.delete(transaction)
-      } else {
-        // same as above
-        transaction._mergeStructs.push(item)
-      }
-    })
-    transaction.changed.delete(this.type)
-  }
-
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {
-    let item = this.type._start
-    while (item !== null) {
-      item.gc(store, true)
-      item = item.right
-    }
-    this.type._start = null
-    this.type._map.forEach(/** @param {Item | null} item */ (item) => {
-      while (item !== null) {
-        item.gc(store, true)
-        item = item.left
-      }
-    })
-    this.type._map = new Map()
-  }
-
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    this.type._write(encoder)
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    return 7
-  }
-}
-
-/**
- * @private
- *
- * @param {AbstractUpdateDecoder} decoder
- * @return {ContentType}
- */
-export const readContentType = decoder => new ContentType(typeRefs[decoder.readTypeRef()](decoder))
--- a/src/structs/GC.js
+++ b/src/structs/GC.js
@@ -1,58 +0,0 @@
-
-import {
-  AbstractStruct,
-  addStruct,
-  AbstractUpdateEncoder, StructStore, Transaction, ID // eslint-disable-line
-} from '../internals.js'
-
-export const structGCRefNumber = 0
-
-/**
- * @private
- */
-export class GC extends AbstractStruct {
-  get deleted () {
-    return true
-  }
-
-  delete () {}
-
-  /**
-   * @param {GC} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    this.length += right.length
-    return true
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {number} offset
-   */
-  integrate (transaction, offset) {
-    if (offset > 0) {
-      this.id.clock += offset
-      this.length -= offset
-    }
-    addStruct(transaction.doc.store, this)
-  }
-
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    encoder.writeInfo(structGCRefNumber)
-    encoder.writeLen(this.length - offset)
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @return {null | number}
-   */
-  getMissing (transaction, store) {
-    return null
-  }
-}
--- a/src/structs/Item.js
+++ b/src/structs/Item.js
@@ -1,775 +0,0 @@
-
-import {
-  GC,
-  getState,
-  AbstractStruct,
-  replaceStruct,
-  addStruct,
-  addToDeleteSet,
-  findRootTypeKey,
-  compareIDs,
-  getItem,
-  getItemCleanEnd,
-  getItemCleanStart,
-  readContentDeleted,
-  readContentBinary,
-  readContentJSON,
-  readContentAny,
-  readContentString,
-  readContentEmbed,
-  createID,
-  readContentFormat,
-  readContentType,
-  addChangedTypeToTransaction,
-  AbstractUpdateDecoder, AbstractUpdateEncoder, ContentType, ContentDeleted, StructStore, ID, AbstractType, Transaction // eslint-disable-line
-} from '../internals.js'
-
-import * as error from 'lib0/error.js'
-import * as maplib from 'lib0/map.js'
-import * as set from 'lib0/set.js'
-import * as binary from 'lib0/binary.js'
-
-/**
- * @todo This should return several items
- *
- * @param {StructStore} store
- * @param {ID} id
- * @return {{item:Item, diff:number}}
- */
-export const followRedone = (store, id) => {
-  /**
-   * @type {ID|null}
-   */
-  let nextID = id
-  let diff = 0
-  let item
-  do {
-    if (diff > 0) {
-      nextID = createID(nextID.client, nextID.clock + diff)
-    }
-    item = getItem(store, nextID)
-    diff = nextID.clock - item.id.clock
-    nextID = item.redone
-  } while (nextID !== null && item instanceof Item)
-  return {
-    item, diff
-  }
-}
-
-/**
- * Make sure that neither item nor any of its parents is ever deleted.
- *
- * This property does not persist when storing it into a database or when
- * sending it to other peers
- *
- * @param {Item|null} item
- * @param {boolean} keep
- */
-export const keepItem = (item, keep) => {
-  while (item !== null && item.keep !== keep) {
-    item.keep = keep
-    item = /** @type {AbstractType<any>} */ (item.parent)._item
-  }
-}
-
-/**
- * Split leftItem into two items
- * @param {Transaction} transaction
- * @param {Item} leftItem
- * @param {number} diff
- * @return {Item}
- *
- * @function
- * @private
- */
-export const splitItem = (transaction, leftItem, diff) => {
-  // create rightItem
-  const { client, clock } = leftItem.id
-  const rightItem = new Item(
-    createID(client, clock + diff),
-    leftItem,
-    createID(client, clock + diff - 1),
-    leftItem.right,
-    leftItem.rightOrigin,
-    leftItem.parent,
-    leftItem.parentSub,
-    leftItem.content.splice(diff)
-  )
-  if (leftItem.deleted) {
-    rightItem.markDeleted()
-  }
-  if (leftItem.keep) {
-    rightItem.keep = true
-  }
-  if (leftItem.redone !== null) {
-    rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff)
-  }
-  // 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.push(rightItem)
-  // update parent._map
-  if (rightItem.parentSub !== null && rightItem.right === null) {
-    /** @type {AbstractType<any>} */ (rightItem.parent)._map.set(rightItem.parentSub, rightItem)
-  }
-  leftItem.length = diff
-  return rightItem
-}
-
-/**
- * Redoes the effect of this operation.
- *
- * @param {Transaction} transaction The Yjs instance.
- * @param {Item} item
- * @param {Set<Item>} redoitems
- *
- * @return {Item|null}
- *
- * @private
- */
-export const redoItem = (transaction, item, redoitems) => {
-  const doc = transaction.doc
-  const store = doc.store
-  const ownClientID = doc.clientID
-  const redone = item.redone
-  if (redone !== null) {
-    return getItemCleanStart(transaction, redone)
-  }
-  let parentItem = /** @type {AbstractType<any>} */ (item.parent)._item
-  /**
-   * @type {Item|null}
-   */
-  let left
-  /**
-   * @type {Item|null}
-   */
-  let right
-  if (item.parentSub === null) {
-    // Is an array item. Insert at the old position
-    left = item.left
-    right = item
-  } else {
-    // Is a map item. Insert as current value
-    left = item
-    while (left.right !== null) {
-      left = left.right
-      if (left.id.client !== ownClientID) {
-        // It is not possible to redo this item because it conflicts with a
-        // change from another client
-        return null
-      }
-    }
-    if (left.right !== null) {
-      left = /** @type {Item} */ (/** @type {AbstractType<any>} */ (item.parent)._map.get(item.parentSub))
-    }
-    right = null
-  }
-  // make sure that parent is redone
-  if (parentItem !== null && parentItem.deleted === true && parentItem.redone === null) {
-    // try to undo parent if it will be undone anyway
-    if (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems) === null) {
-      return null
-    }
-  }
-  if (parentItem !== null && parentItem.redone !== null) {
-    while (parentItem.redone !== null) {
-      parentItem = getItemCleanStart(transaction, parentItem.redone)
-    }
-    // find next cloned_redo items
-    while (left !== null) {
-      /**
-       * @type {Item|null}
-       */
-      let leftTrace = left
-      // trace redone until parent matches
-      while (leftTrace !== null && /** @type {AbstractType<any>} */ (leftTrace.parent)._item !== parentItem) {
-        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone)
-      }
-      if (leftTrace !== null && /** @type {AbstractType<any>} */ (leftTrace.parent)._item === parentItem) {
-        left = leftTrace
-        break
-      }
-      left = left.left
-    }
-    while (right !== null) {
-      /**
-       * @type {Item|null}
-       */
-      let rightTrace = right
-      // trace redone until parent matches
-      while (rightTrace !== null && /** @type {AbstractType<any>} */ (rightTrace.parent)._item !== parentItem) {
-        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone)
-      }
-      if (rightTrace !== null && /** @type {AbstractType<any>} */ (rightTrace.parent)._item === parentItem) {
-        right = rightTrace
-        break
-      }
-      right = right.right
-    }
-  }
-  const nextClock = getState(store, ownClientID)
-  const nextId = createID(ownClientID, nextClock)
-  const redoneItem = new Item(
-    nextId,
-    left, left && left.lastId,
-    right, right && right.id,
-    parentItem === null ? item.parent : /** @type {ContentType} */ (parentItem.content).type,
-    item.parentSub,
-    item.content.copy()
-  )
-  item.redone = nextId
-  keepItem(redoneItem, true)
-  redoneItem.integrate(transaction, 0)
-  return redoneItem
-}
-
-/**
- * Abstract class that represents any content.
- */
-export class Item extends AbstractStruct {
-  /**
-   * @param {ID} id
-   * @param {Item | null} left
-   * @param {ID | null} origin
-   * @param {Item | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>|ID|null} parent Is a type if integrated, is null if it is possible to copy parent from left or right, is ID before integration to search for it.
-   * @param {string | null} parentSub
-   * @param {AbstractContent} content
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {
-    super(id, content.getLength())
-    /**
-     * The item that was originally to the left of this item.
-     * @type {ID | null}
-     */
-    this.origin = origin
-    /**
-     * The item that is currently to the left of this item.
-     * @type {Item | null}
-     */
-    this.left = left
-    /**
-     * The item that is currently to the right of this item.
-     * @type {Item | null}
-     */
-    this.right = right
-    /**
-     * The item that was originally to the right of this item.
-     * @type {ID | null}
-     */
-    this.rightOrigin = rightOrigin
-    /**
-     * @type {AbstractType<any>|ID|null}
-     */
-    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}
-     */
-    this.parentSub = parentSub
-    /**
-     * If this type's effect is reundone this type refers to the type that undid
-     * this operation.
-     * @type {ID | null}
-     */
-    this.redone = null
-    /**
-     * @type {AbstractContent}
-     */
-    this.content = content
-    /**
-     * bit1: keep
-     * bit2: countable
-     * bit3: deleted
-     * bit4: mark - mark node as fast-search-marker
-     * @type {number} byte
-     */
-    this.info = this.content.isCountable() ? binary.BIT2 : 0
-  }
-
-  /**
-   * This is used to mark the item as an indexed fast-search marker
-   *
-   * @type {boolean}
-   */
-  set marker (isMarked) {
-    if (((this.info & binary.BIT4) > 0) !== isMarked) {
-      this.info ^= binary.BIT4
-    }
-  }
-
-  get marker () {
-    return (this.info & binary.BIT4) > 0
-  }
-
-  /**
-   * If true, do not garbage collect this Item.
-   */
-  get keep () {
-    return (this.info & binary.BIT1) > 0
-  }
-
-  set keep (doKeep) {
-    if (this.keep !== doKeep) {
-      this.info ^= binary.BIT1
-    }
-  }
-
-  get countable () {
-    return (this.info & binary.BIT2) > 0
-  }
-
-  /**
-   * Whether this item was deleted or not.
-   * @type {Boolean}
-   */
-  get deleted () {
-    return (this.info & binary.BIT3) > 0
-  }
-
-  set deleted (doDelete) {
-    if (this.deleted !== doDelete) {
-      this.info ^= binary.BIT3
-    }
-  }
-
-  markDeleted () {
-    this.info |= binary.BIT3
-  }
-
-  /**
-   * Return the creator clientID of the missing op or define missing items and return null.
-   *
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @return {null | number}
-   */
-  getMissing (transaction, store) {
-    if (this.origin && this.origin.client !== this.id.client && this.origin.clock >= getState(store, this.origin.client)) {
-      return this.origin.client
-    }
-    if (this.rightOrigin && this.rightOrigin.client !== this.id.client && this.rightOrigin.clock >= getState(store, this.rightOrigin.client)) {
-      return this.rightOrigin.client
-    }
-    if (this.parent && this.parent.constructor === ID && this.id.client !== this.parent.client && this.parent.clock >= getState(store, this.parent.client)) {
-      return this.parent.client
-    }
-
-    // We have all missing ids, now find the items
-
-    if (this.origin) {
-      this.left = getItemCleanEnd(transaction, store, this.origin)
-      this.origin = this.left.lastId
-    }
-    if (this.rightOrigin) {
-      this.right = getItemCleanStart(transaction, this.rightOrigin)
-      this.rightOrigin = this.right.id
-    }
-    if ((this.left && this.left.constructor === GC) || (this.right && this.right.constructor === GC)) {
-      this.parent = null
-    }
-    // only set parent if this shouldn't be garbage collected
-    if (!this.parent) {
-      if (this.left && this.left.constructor === Item) {
-        this.parent = this.left.parent
-        this.parentSub = this.left.parentSub
-      }
-      if (this.right && this.right.constructor === Item) {
-        this.parent = this.right.parent
-        this.parentSub = this.right.parentSub
-      }
-    } else if (this.parent.constructor === ID) {
-      const parentItem = getItem(store, this.parent)
-      if (parentItem.constructor === GC) {
-        this.parent = null
-      } else {
-        this.parent = /** @type {ContentType} */ (parentItem.content).type
-      }
-    }
-    return null
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {number} offset
-   */
-  integrate (transaction, offset) {
-    if (offset > 0) {
-      this.id.clock += offset
-      this.left = getItemCleanEnd(transaction, transaction.doc.store, createID(this.id.client, this.id.clock - 1))
-      this.origin = this.left.lastId
-      this.content = this.content.splice(offset)
-      this.length -= offset
-    }
-
-    if (this.parent) {
-      if ((!this.left && (!this.right || this.right.left !== null)) || (this.left && this.left.right !== this.right)) {
-        /**
-         * @type {Item|null}
-         */
-        let left = this.left
-
-        /**
-         * @type {Item|null}
-         */
-        let o
-        // set o to the first conflicting item
-        if (left !== null) {
-          o = left.right
-        } else if (this.parentSub !== null) {
-          o = /** @type {AbstractType<any>} */ (this.parent)._map.get(this.parentSub) || null
-          while (o !== null && o.left !== null) {
-            o = o.left
-          }
-        } else {
-          o = /** @type {AbstractType<any>} */ (this.parent)._start
-        }
-        // TODO: use something like DeleteSet here (a tree implementation would be best)
-        // @todo use global set definitions
-        /**
-         * @type {Set<Item>}
-         */
-        const conflictingItems = new Set()
-        /**
-         * @type {Set<Item>}
-         */
-        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 < this.id.client) {
-              left = o
-              conflictingItems.clear()
-            } else if (compareIDs(this.rightOrigin, o.rightOrigin)) {
-              // this and o are conflicting and point to the same integration points. The id decides which item comes first.
-              // Since this is to the left of o, we can break here
-              break
-            } // else, o might be integrated before an item that this conflicts with. If so, we will find it in the next iterations
-          } else if (o.origin !== null && itemsBeforeOrigin.has(getItem(transaction.doc.store, o.origin))) { // use getItem instead of getItemCleanEnd because we don't want / need to split items.
-            // case 2
-            if (!conflictingItems.has(getItem(transaction.doc.store, o.origin))) {
-              left = o
-              conflictingItems.clear()
-            }
-          } else {
-            break
-          }
-          o = o.right
-        }
-        this.left = left
-      }
-      // 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 (this.parentSub !== null) {
-          r = /** @type {AbstractType<any>} */ (this.parent)._map.get(this.parentSub) || null
-          while (r !== null && r.left !== null) {
-            r = r.left
-          }
-        } else {
-          r = /** @type {AbstractType<any>} */ (this.parent)._start
-          ;/** @type {AbstractType<any>} */ (this.parent)._start = this
-        }
-        this.right = r
-      }
-      if (this.right !== null) {
-        this.right.left = this
-      } else if (this.parentSub !== null) {
-        // set as current parent value if right === null and this is parentSub
-        /** @type {AbstractType<any>} */ (this.parent)._map.set(this.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 (this.parentSub === null && this.countable && !this.deleted) {
-        /** @type {AbstractType<any>} */ (this.parent)._length += this.length
-      }
-      addStruct(transaction.doc.store, this)
-      this.content.integrate(transaction, this)
-      // add parent to transaction.changed
-      addChangedTypeToTransaction(transaction, /** @type {AbstractType<any>} */ (this.parent), this.parentSub)
-      if ((/** @type {AbstractType<any>} */ (this.parent)._item !== null && /** @type {AbstractType<any>} */ (this.parent)._item.deleted) || (this.parentSub !== null && this.right !== null)) {
-        // delete if parent is deleted or if this is not the current attribute value of parent
-        this.delete(transaction)
-      }
-    } else {
-      // parent is not defined. Integrate GC struct instead
-      new GC(this.id, this.length).integrate(transaction, 0)
-    }
-  }
-
-  /**
-   * Returns the next non-deleted item
-   */
-  get next () {
-    let n = this.right
-    while (n !== null && n.deleted) {
-      n = n.right
-    }
-    return n
-  }
-
-  /**
-   * Returns the previous non-deleted item
-   */
-  get prev () {
-    let n = this.left
-    while (n !== null && n.deleted) {
-      n = n.left
-    }
-    return n
-  }
-
-  /**
-   * Computes the last content address of this Item.
-   */
-  get lastId () {
-    // allocating ids is pretty costly because of the amount of ids created, so we try to reuse whenever possible
-    return this.length === 1 ? this.id : createID(this.id.client, this.id.clock + this.length - 1)
-  }
-
-  /**
-   * Try to merge two items
-   *
-   * @param {Item} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    if (
-      compareIDs(right.origin, this.lastId) &&
-      this.right === right &&
-      compareIDs(this.rightOrigin, right.rightOrigin) &&
-      this.id.client === right.id.client &&
-      this.id.clock + this.length === right.id.clock &&
-      this.deleted === right.deleted &&
-      this.redone === null &&
-      right.redone === null &&
-      this.content.constructor === right.content.constructor &&
-      this.content.mergeWith(right.content)
-    ) {
-      if (right.keep) {
-        this.keep = true
-      }
-      this.right = right.right
-      if (this.right !== null) {
-        this.right.left = this
-      }
-      this.length += right.length
-      return true
-    }
-    return false
-  }
-
-  /**
-   * Mark this Item as deleted.
-   *
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {
-    if (!this.deleted) {
-      const parent = /** @type {AbstractType<any>} */ (this.parent)
-      // adjust the length of parent
-      if (this.countable && this.parentSub === null) {
-        parent._length -= this.length
-      }
-      this.markDeleted()
-      addToDeleteSet(transaction.deleteSet, this.id.client, this.id.clock, this.length)
-      maplib.setIfUndefined(transaction.changed, parent, set.create).add(this.parentSub)
-      this.content.delete(transaction)
-    }
-  }
-
-  /**
-   * @param {StructStore} store
-   * @param {boolean} parentGCd
-   */
-  gc (store, parentGCd) {
-    if (!this.deleted) {
-      throw error.unexpectedCase()
-    }
-    this.content.gc(store)
-    if (parentGCd) {
-      replaceStruct(store, this, new GC(this.id, this.length))
-    } else {
-      this.content = new ContentDeleted(this.length)
-    }
-  }
-
-  /**
-   * 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 {AbstractUpdateEncoder} encoder The encoder to write data to.
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    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 = (this.content.getRef() & 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
-    encoder.writeInfo(info)
-    if (origin !== null) {
-      encoder.writeLeftID(origin)
-    }
-    if (rightOrigin !== null) {
-      encoder.writeRightID(rightOrigin)
-    }
-    if (origin === null && rightOrigin === null) {
-      const parent = /** @type {AbstractType<any>} */ (this.parent)
-      const parentItem = parent._item
-      if (parentItem === null) {
-        // parent type on y._map
-        // find the correct key
-        const ykey = findRootTypeKey(parent)
-        encoder.writeParentInfo(true) // write parentYKey
-        encoder.writeString(ykey)
-      } else {
-        encoder.writeParentInfo(false) // write parent id
-        encoder.writeLeftID(parentItem.id)
-      }
-      if (parentSub !== null) {
-        encoder.writeString(parentSub)
-      }
-    }
-    this.content.write(encoder, offset)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @param {number} info
- */
-export const readItemContent = (decoder, info) => contentRefs[info & binary.BITS5](decoder)
-
-/**
- * A lookup map for reading Item content.
- *
- * @type {Array<function(AbstractUpdateDecoder):AbstractContent>}
- */
-export const contentRefs = [
-  () => { throw error.unexpectedCase() }, // GC is not ItemContent
-  readContentDeleted,
-  readContentJSON,
-  readContentBinary,
-  readContentString,
-  readContentEmbed,
-  readContentFormat,
-  readContentType,
-  readContentAny
-]
-
-/**
- * Do not implement this class!
- */
-export class AbstractContent {
-  /**
-   * @return {number}
-   */
-  getLength () {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * 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
-   *
-   * @return {boolean}
-   */
-  isCountable () {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @return {AbstractContent}
-   */
-  copy () {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {number} offset
-   * @return {AbstractContent}
-   */
-  splice (offset) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {AbstractContent} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate (transaction, item) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {Transaction} transaction
-   */
-  delete (transaction) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {StructStore} store
-   */
-  gc (store) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @return {number}
-   */
-  getRef () {
-    throw error.methodUnimplemented()
-  }
-}
--- a/src/types/AbstractType.js
+++ b/src/types/AbstractType.js
@@ -1,845 +0,0 @@
-
-import {
-  removeEventHandlerListener,
-  callEventHandlerListeners,
-  addEventHandlerListener,
-  createEventHandler,
-  getState,
-  isVisible,
-  ContentType,
-  createID,
-  ContentAny,
-  ContentBinary,
-  getItemCleanStart,
-  YText, YArray, AbstractUpdateEncoder, Doc, Snapshot, Transaction, EventHandler, YEvent, Item, // 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 math from 'lib0/math.js'
-
-const maxSearchMarker = 80
-
-/**
- * A unique timestamp that identifies each marker.
- *
- * Time is relative,.. this is more like an ever-increasing clock.
- *
- * @type {number}
- */
-let globalSearchMarkerTimestamp = 0
-
-export class ArraySearchMarker {
-  /**
-   * @param {Item} p
-   * @param {number} index
-   */
-  constructor (p, index) {
-    p.marker = true
-    this.p = p
-    this.index = index
-    this.timestamp = globalSearchMarkerTimestamp++
-  }
-}
-
-/**
- * @param {ArraySearchMarker} marker
- */
-const refreshMarkerTimestamp = marker => { marker.timestamp = globalSearchMarkerTimestamp++ }
-
-/**
- * This is rather complex so this function is the only thing that should overwrite a marker
- *
- * @param {ArraySearchMarker} marker
- * @param {Item} p
- * @param {number} index
- */
-const overwriteMarker = (marker, p, index) => {
-  marker.p.marker = false
-  marker.p = p
-  p.marker = true
-  marker.index = index
-  marker.timestamp = globalSearchMarkerTimestamp++
-}
-
-/**
- * @param {Array<ArraySearchMarker>} searchMarker
- * @param {Item} p
- * @param {number} index
- */
-const markPosition = (searchMarker, p, index) => {
-  if (searchMarker.length >= maxSearchMarker) {
-    // override oldest marker (we don't want to create more objects)
-    const marker = searchMarker.reduce((a, b) => a.timestamp < b.timestamp ? a : b)
-    overwriteMarker(marker, p, index)
-    return marker
-  } else {
-    // create new marker
-    const pm = new ArraySearchMarker(p, index)
-    searchMarker.push(pm)
-    return pm
-  }
-}
-
-/**
- * Search marker help us to find positions in the associative array faster.
- *
- * They speed up the process of finding a position without much bookkeeping.
- *
- * A maximum of `maxSearchMarker` objects are created.
- *
- * This function always returns a refreshed marker (updated timestamp)
- *
- * @param {AbstractType<any>} yarray
- * @param {number} index
- */
-export const findMarker = (yarray, index) => {
-  if (yarray._start === null || index === 0 || yarray._searchMarker === null) {
-    return null
-  }
-  const marker = yarray._searchMarker.length === 0 ? null : yarray._searchMarker.reduce((a, b) => math.abs(index - a.index) < math.abs(index - b.index) ? a : b)
-  let p = yarray._start
-  let pindex = 0
-  if (marker !== null) {
-    p = marker.p
-    pindex = marker.index
-    refreshMarkerTimestamp(marker) // we used it, we might need to use it again
-  }
-  // iterate to right if possible
-  while (p.right !== null && pindex < index) {
-    if (!p.deleted && p.countable) {
-      if (index < pindex + p.length) {
-        break
-      }
-      pindex += p.length
-    }
-    p = p.right
-  }
-  // iterate to left if necessary (might be that pindex > index)
-  while (p.left !== null && pindex > index) {
-    p = p.left
-    if (!p.deleted && p.countable) {
-      pindex -= p.length
-    }
-  }
-  // we want to make sure that p can't be merged with left, because that would screw up everything
-  // in that cas just return what we have (it is most likely the best marker anyway)
-  // iterate to left until p can't be merged with left
-  while (p.left !== null && p.left.id.client === p.id.client && p.left.id.clock + p.left.length === p.id.clock) {
-    p = p.left
-    if (!p.deleted && p.countable) {
-      pindex -= p.length
-    }
-  }
-
-  // @todo remove!
-  // assure position
-  // {
-  //   let start = yarray._start
-  //   let pos = 0
-  //   while (start !== p) {
-  //     if (!start.deleted && start.countable) {
-  //       pos += start.length
-  //     }
-  //     start = /** @type {Item} */ (start.right)
-  //   }
-  //   if (pos !== pindex) {
-  //     debugger
-  //     throw new Error('Gotcha position fail!')
-  //   }
-  // }
-  // if (marker) {
-  //   if (window.lengthes == null) {
-  //     window.lengthes = []
-  //     window.getLengthes = () => window.lengthes.sort((a, b) => a - b)
-  //   }
-  //   window.lengthes.push(marker.index - pindex)
-  //   console.log('distance', marker.index - pindex, 'len', p && p.parent.length)
-  // }
-  if (marker !== null && math.abs(marker.index - pindex) < /** @type {YText|YArray<any>} */ (p.parent).length / maxSearchMarker) {
-    // adjust existing marker
-    overwriteMarker(marker, p, pindex)
-    return marker
-  } else {
-    // create new marker
-    return markPosition(yarray._searchMarker, p, pindex)
-  }
-}
-
-/**
- * Update markers when a change happened.
- *
- * This should be called before doing a deletion!
- *
- * @param {Array<ArraySearchMarker>} searchMarker
- * @param {number} index
- * @param {number} len If insertion, len is positive. If deletion, len is negative.
- */
-export const updateMarkerChanges = (searchMarker, index, len) => {
-  for (let i = searchMarker.length - 1; i >= 0; i--) {
-    const m = searchMarker[i]
-    if (len > 0) {
-      /**
-       * @type {Item|null}
-       */
-      let p = m.p
-      p.marker = false
-      // Ideally we just want to do a simple position comparison, but this will only work if
-      // search markers don't point to deleted items for formats.
-      // Iterate marker to prev undeleted countable position so we know what to do when updating a position
-      while (p && (p.deleted || !p.countable)) {
-        p = p.left
-        if (p && !p.deleted && p.countable) {
-          // adjust position. the loop should break now
-          m.index -= p.length
-        }
-      }
-      if (p === null || p.marker === true) {
-        // remove search marker if updated position is null or if position is already marked
-        searchMarker.splice(i, 1)
-        continue
-      }
-      m.p = p
-      p.marker = true
-    }
-    if (index < m.index || (len > 0 && index === m.index)) { // a simple index <= m.index check would actually suffice
-      m.index = math.max(index, m.index + len)
-    }
-  }
-}
-
-/**
- * Accumulate all (list) children of a type and return them as an Array.
- *
- * @param {AbstractType<any>} t
- * @return {Array<Item>}
- */
-export const getTypeChildren = t => {
-  let s = t._start
-  const arr = []
-  while (s) {
-    arr.push(s)
-    s = s.right
-  }
-  return arr
-}
-
-/**
- * Call event listeners with an event. This will also add an event to all
- * parents (for `.observeDeep` handlers).
- *
- * @template EventType
- * @param {AbstractType<EventType>} type
- * @param {Transaction} transaction
- * @param {EventType} event
- */
-export const callTypeObservers = (type, transaction, event) => {
-  const changedType = type
-  const changedParentTypes = transaction.changedParentTypes
-  while (true) {
-    // @ts-ignore
-    map.setIfUndefined(changedParentTypes, type, () => []).push(event)
-    if (type._item === null) {
-      break
-    }
-    type = /** @type {AbstractType<any>} */ (type._item.parent)
-  }
-  callEventHandlerListeners(changedType._eH, event, transaction)
-}
-
-/**
- * @template EventType
- * Abstract Yjs Type class
- */
-export class AbstractType {
-  constructor () {
-    /**
-     * @type {Item|null}
-     */
-    this._item = null
-    /**
-     * @type {Map<string,Item>}
-     */
-    this._map = new Map()
-    /**
-     * @type {Item|null}
-     */
-    this._start = null
-    /**
-     * @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()
-    /**
-     * @type {null | Array<ArraySearchMarker>}
-     */
-    this._searchMarker = null
-  }
-
-  /**
-   * 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 {Item|null} item
-   */
-  _integrate (y, item) {
-    this.doc = y
-    this._item = item
-  }
-
-  /**
-   * @return {AbstractType<EventType>}
-   */
-  _copy () {
-    throw error.methodUnimplemented()
-  }
-
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   */
-  _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.
-   */
-  _callObserver (transaction, parentSubs) {
-    if (!transaction.local && this._searchMarker) {
-      this._searchMarker.length = 0
-    }
-  }
-
-  /**
-   * 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 {any}
-   */
-  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.content.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.content.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.content.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
-          }
-        }
-        // we found n, so we can set currentContent
-        currentContent = n.content.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.content.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) => {
-  const marker = findMarker(type, index)
-  let n = type._start
-  if (marker !== null) {
-    n = marker.p
-    index -= marker.index
-  }
-  for (; n !== null; n = n.right) {
-    if (!n.deleted && n.countable) {
-      if (index < n.length) {
-        return n.content.getContent()[index]
-      }
-      index -= n.length
-    }
-  }
-}
-
-/**
- * @param {Transaction} transaction
- * @param {AbstractType<any>} parent
- * @param {Item?} 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 doc = transaction.doc
-  const ownClientId = doc.clientID
-  const store = doc.store
-  const right = referenceItem === null ? parent._start : referenceItem.right
-  /**
-   * @type {Array<Object|Array<any>|number>}
-   */
-  let jsonContent = []
-  const packJsonContent = () => {
-    if (jsonContent.length > 0) {
-      left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentAny(jsonContent))
-      left.integrate(transaction, 0)
-      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 Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentBinary(new Uint8Array(/** @type {Uint8Array} */ (c))))
-            left.integrate(transaction, 0)
-            break
-          default:
-            if (c instanceof AbstractType) {
-              left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentType(c))
-              left.integrate(transaction, 0)
-            } 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) {
-    if (parent._searchMarker) {
-      updateMarkerChanges(parent._searchMarker, index, content.length)
-    }
-    return typeListInsertGenericsAfter(transaction, parent, null, content)
-  }
-  const startIndex = index
-  const marker = findMarker(parent, index)
-  let n = parent._start
-  if (marker !== null) {
-    n = marker.p
-    index -= marker.index
-    // we need to iterate one to the left so that the algorithm works
-    if (index === 0) {
-      // @todo refactor this as it actually doesn't consider formats
-      n = n.prev // important! get the left undeleted item so that we can actually decrease index
-      index += (n && n.countable && !n.deleted) ? n.length : 0
-    }
-  }
-  for (; n !== null; n = n.right) {
-    if (!n.deleted && n.countable) {
-      if (index <= n.length) {
-        if (index < n.length) {
-          // insert in-between
-          getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index))
-        }
-        break
-      }
-      index -= n.length
-    }
-  }
-  if (parent._searchMarker) {
-    updateMarkerChanges(parent._searchMarker, startIndex, content.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 }
-  const startIndex = index
-  const startLength = length
-  const marker = findMarker(parent, index)
-  let n = parent._start
-  if (marker !== null) {
-    n = marker.p
-    index -= marker.index
-  }
-  // 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, 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, 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')
-  }
-  if (parent._searchMarker) {
-    updateMarkerChanges(parent._searchMarker, startIndex, -startLength + length /* in case we remove the above exception */)
-  }
-}
-
-/**
- * @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
-  const doc = transaction.doc
-  const ownClientId = doc.clientID
-  let content
-  if (value == null) {
-    content = new ContentAny([value])
-  } else {
-    switch (value.constructor) {
-      case Number:
-      case Object:
-      case Boolean:
-      case Array:
-      case String:
-        content = new ContentAny([value])
-        break
-      case Uint8Array:
-        content = new ContentBinary(/** @type {Uint8Array} */ (value))
-        break
-      default:
-        if (value instanceof AbstractType) {
-          content = new ContentType(value)
-        } else {
-          throw new Error('Unexpected content type')
-        }
-    }
-  }
-  new Item(createID(ownClientId, getState(doc.store, ownClientId)), left, left && left.lastId, null, null, parent, key, content).integrate(transaction, 0)
-}
-
-/**
- * @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.content.getContent()[val.length - 1] : 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>}
-   */
-  const res = {}
-  parent._map.forEach((value, key) => {
-    if (!value.deleted) {
-      res[key] = value.content.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.sv.has(v.id.client) || v.id.clock >= (snapshot.sv.get(v.id.client) || 0))) {
-    v = v.left
-  }
-  return v !== null && isVisible(v, snapshot) ? v.content.getContent()[v.length - 1] : undefined
-}
-
-/**
- * @param {Map<string,Item>} 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
@@ -1,222 +0,0 @@
-/**
- * @module YArray
- */
-
-import {
-  YEvent,
-  AbstractType,
-  typeListGet,
-  typeListToArray,
-  typeListForEach,
-  typeListCreateIterator,
-  typeListInsertGenerics,
-  typeListDelete,
-  typeListMap,
-  YArrayRefID,
-  callTypeObservers,
-  transact,
-  ArraySearchMarker, AbstractUpdateDecoder, AbstractUpdateEncoder, Doc, Transaction, Item // eslint-disable-line
-} from '../internals.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 {Iterable<T>}
- */
-export class YArray extends AbstractType {
-  constructor () {
-    super()
-    /**
-     * @type {Array<any>?}
-     * @private
-     */
-    this._prelimContent = []
-    /**
-     * @type {Array<ArraySearchMarker>}
-     */
-    this._searchMarker = []
-  }
-
-  /**
-   * 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 {Item} item
-   */
-  _integrate (y, item) {
-    super._integrate(y, item)
-    this.insert(0, /** @type {Array<any>} */ (this._prelimContent))
-    this._prelimContent = null
-  }
-
-  _copy () {
-    return new YArray()
-  }
-
-  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.
-   */
-  _callObserver (transaction, parentSubs) {
-    super._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 {
-      /** @type {Array<any>} */ (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)
-  }
-
-  /**
-   * Preppends content to this YArray.
-   *
-   * @param {Array<T>} content Array of content to preppend.
-   */
-  unshift (content) {
-    this.insert(0, 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 {
-      /** @type {Array<any>} */ (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) {
-    return typeListMap(this, /** @type {any} */ (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 {AbstractUpdateEncoder} encoder
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YArrayRefID)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- *
- * @private
- * @function
- */
-export const readYArray = decoder => new YArray()
--- a/src/types/YMap.js
+++ b/src/types/YMap.js
@@ -1,243 +0,0 @@
-
-/**
- * @module YMap
- */
-
-import {
-  YEvent,
-  AbstractType,
-  typeMapDelete,
-  typeMapSet,
-  typeMapGet,
-  typeMapHas,
-  createMapIterator,
-  YMapRefID,
-  callTypeObservers,
-  transact,
-  AbstractUpdateDecoder, AbstractUpdateEncoder, Doc, Transaction, Item // eslint-disable-line
-} from '../internals.js'
-
-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 {Iterable<T>}
- */
-export class YMap extends AbstractType {
-  /**
-   *
-   * @param {Iterable<readonly [string, any]>=} entries - an optional iterable to initialize the YMap
-   */
-  constructor (entries) {
-    super()
-    /**
-     * @type {Map<string,any>?}
-     * @private
-     */
-    this._prelimContent = null
-
-    if (entries === undefined) {
-      this._prelimContent = new Map()
-    } else {
-      this._prelimContent = new Map(entries)
-    }
-  }
-
-  /**
-   * 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 {Item} item
-   */
-  _integrate (y, item) {
-    super._integrate(y, item)
-    ;/** @type {Map<string, any>} */ (this._prelimContent).forEach((value, key) => {
-      this.set(key, value)
-    })
-    this._prelimContent = null
-  }
-
-  _copy () {
-    return new YMap()
-  }
-
-  /**
-   * Creates YMapEvent and calls observers.
-   *
-   * @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 YMapEvent(this, transaction, parentSubs))
-  }
-
-  /**
-   * Transforms this Shared Type to a JSON object.
-   *
-   * @return {Object<string,T>}
-   */
-  toJSON () {
-    /**
-     * @type {Object<string,T>}
-     */
-    const map = {}
-    this._map.forEach((item, key) => {
-      if (!item.deleted) {
-        const v = item.content.getContent()[item.length - 1]
-        map[key] = v instanceof AbstractType ? v.toJSON() : v
-      }
-    })
-    return map
-  }
-
-  /**
-   * Returns the size of the YMap (count of key/value pairs)
-   *
-   * @return {number}
-   */
-  get size () {
-    return [...createMapIterator(this._map)].length
-  }
-
-  /**
-   * Returns the keys for each element in the YMap Type.
-   *
-   * @return {IterableIterator<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 {IterableIterator<string>}
-   */
-  values () {
-    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[1].content.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].content.getContent()[v[1].length - 1]])
-  }
-
-  /**
-   * Executes a provided function on once on every key-value pair.
-   *
-   * @param {function(T,string,YMap<T>):void} f A function to execute on every element of this YArray.
-   */
-  forEach (f) {
-    /**
-     * @type {Object<string,T>}
-     */
-    const map = {}
-    this._map.forEach((item, key) => {
-      if (!item.deleted) {
-        f(item.content.getContent()[item.length - 1], key, this)
-      }
-    })
-    return map
-  }
-
-  /**
-   * @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 {
-      /** @type {Map<string, any>} */ (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 {
-      /** @type {Map<string, any>} */ (this._prelimContent).set(key, value)
-    }
-    return value
-  }
-
-  /**
-   * Returns a specified element from this YMap.
-   *
-   * @param {string} key
-   * @return {T|undefined}
-   */
-  get (key) {
-    return /** @type {any} */ (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 {AbstractUpdateEncoder} encoder
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YMapRefID)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- *
- * @private
- * @function
- */
-export const readYMap = decoder => new YMap()
--- a/src/types/YText.js
+++ b/src/types/YText.js
--- a/src/types/YXmlElement.js
+++ b/src/types/YXmlElement.js
@@ -1,195 +0,0 @@
-
-import {
-  YXmlFragment,
-  transact,
-  typeMapDelete,
-  typeMapSet,
-  typeMapGet,
-  typeMapGetAll,
-  typeListForEach,
-  YXmlElementRefID,
-  AbstractUpdateDecoder, AbstractUpdateEncoder, Snapshot, Doc, Item // eslint-disable-line
-} from '../internals.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
-    /**
-     * @type {Map<string, any>|null}
-     */
-    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 {Item} item
-   */
-  _integrate (y, item) {
-    super._integrate(y, item)
-    ;(/** @type {Map<string, any>} */ (this._prelimAttrs)).forEach((value, key) => {
-      this.setAttribute(key, value)
-    })
-    this._prelimAttrs = null
-  }
-
-  /**
-   * Creates an Item with the same effect as this Item (without position effect)
-   *
-   * @return {YXmlElement}
-   */
-  _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 (const 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 {
-      /** @type {Map<string,any>} */ (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 {
-      /** @type {Map<string, any>} */ (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) {
-    return /** @type {any} */ (typeMapGet(this, attributeName))
-  }
-
-  /**
-   * Returns all attribute name/value pairs in a JSON Object.
-   *
-   * @param {Snapshot} [snapshot]
-   * @return {Object<string, any>} 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)
-    const attrs = this.getAttributes()
-    for (const 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.
-   *
-   * @param {AbstractUpdateEncoder} encoder The encoder to write data to.
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YXmlElementRefID)
-    encoder.writeKey(this.nodeName)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {YXmlElement}
- *
- * @function
- */
-export const readYXmlElement = decoder => new YXmlElement(decoder.readKey())
--- a/src/types/YXmlEvent.js
+++ b/src/types/YXmlEvent.js
@@ -1,39 +0,0 @@
-
-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
@@ -1,339 +0,0 @@
-/**
- * @module YXml
- */
-
-import {
-  YXmlEvent,
-  YXmlElement,
-  AbstractType,
-  typeListMap,
-  typeListForEach,
-  typeListInsertGenerics,
-  typeListDelete,
-  typeListToArray,
-  YXmlFragmentRefID,
-  callTypeObservers,
-  transact,
-  AbstractUpdateDecoder, AbstractUpdateEncoder, Doc, ContentType, Transaction, Item, YXmlText, YXmlHook, Snapshot // eslint-disable-line
-} from '../internals.js'
-
-/**
- * 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 {Iterable<YXmlElement|YXmlText|YXmlElement|YXmlHook>}
- */
-export class YXmlTreeWalker {
-  /**
-   * @param {YXmlFragment | YXmlElement} root
-   * @param {function(AbstractType<any>):boolean} [f]
-   */
-  constructor (root, f = () => true) {
-    this._filter = f
-    this._root = root
-    /**
-     * @type {Item}
-     */
-    this._currentNode = /** @type {Item} */ (root._start)
-    this._firstCall = true
-  }
-
-  [Symbol.iterator] () {
-    return this
-  }
-
-  /**
-   * Get the next node.
-   *
-   * @return {IteratorResult<YXmlElement|YXmlText|YXmlHook>} The next node.
-   *
-   * @public
-   */
-  next () {
-    /**
-     * @type {Item|null}
-     */
-    let n = this._currentNode
-    let type = /** @type {any} */ (n.content).type
-    if (n !== null && (!this._firstCall || n.deleted || !this._filter(type))) { // if first call, we check if we can use the first item
-      do {
-        type = /** @type {any} */ (n.content).type
-        if (!n.deleted && (type.constructor === YXmlElement || type.constructor === YXmlFragment) && type._start !== null) {
-          // walk down in the tree
-          n = type._start
-        } else {
-          // walk right or up in the tree
-          while (n !== null) {
-            if (n.right !== null) {
-              n = n.right
-              break
-            } else if (n.parent === this._root) {
-              n = null
-            } else {
-              n = /** @type {AbstractType<any>} */ (n.parent)._item
-            }
-          }
-        }
-      } while (n !== null && (n.deleted || !this._filter(/** @type {ContentType} */ (n.content).type)))
-    }
-    this._firstCall = false
-    if (n === null) {
-      // @ts-ignore
-      return { value: undefined, done: true }
-    }
-    this._currentNode = n
-    return { value: /** @type {any} */ (n.content).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}
-     */
-    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 {Item} item
-   */
-  _integrate (y, item) {
-    super._integrate(y, item)
-    this.insert(0, /** @type {Array<any>} */ (this._prelimContent))
-    this._prelimContent = null
-  }
-
-  _copy () {
-    return new YXmlFragment()
-  }
-
-  get length () {
-    return this._prelimContent === null ? this._length : this._prelimContent.length
-  }
-
-  /**
-   * 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 && element.nodeName.toUpperCase() === 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 && element.nodeName.toUpperCase() === query))
-  }
-
-  /**
-   * Creates YXmlEvent and calls observers.
-   *
-   * @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('')
-  }
-
-  /**
-   * @return {string}
-   */
-  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.
-   *
-   * @param {AbstractUpdateEncoder} encoder The encoder to write data to.
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YXmlFragmentRefID)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {YXmlFragment}
- *
- * @private
- * @function
- */
-export const readYXmlFragment = decoder => new YXmlFragment()
--- a/src/types/YXmlHook.js
+++ b/src/types/YXmlHook.js
@@ -1,84 +0,0 @@
-
-import {
-  YMap,
-  YXmlHookRefID,
-  AbstractUpdateDecoder, AbstractUpdateEncoder // eslint-disable-line
-} from '../internals.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)
-   */
-  _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 {AbstractUpdateEncoder} encoder The encoder to write data to.
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YXmlHookRefID)
-    encoder.writeKey(this.hookName)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {YXmlHook}
- *
- * @private
- * @function
- */
-export const readYXmlHook = decoder =>
-  new YXmlHook(decoder.readKey())
--- a/src/types/YXmlText.js
+++ b/src/types/YXmlText.js
@@ -1,96 +0,0 @@
-
-import {
-  YText,
-  YXmlTextRefID,
-  AbstractUpdateDecoder, AbstractUpdateEncoder // eslint-disable-line
-} from '../internals.js'
-
-/**
- * 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 {
-  _copy () {
-    return new YXmlText()
-  }
-
-  /**
-   * 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 (const nodeName in delta.attributes) {
-        const attrs = []
-        for (const 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[j]
-          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('')
-  }
-
-  /**
-   * @return {string}
-   */
-  toJSON () {
-    return this.toString()
-  }
-
-  /**
-   * @param {AbstractUpdateEncoder} encoder
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YXmlTextRefID)
-  }
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder
- * @return {YXmlText}
- *
- * @private
- * @function
- */
-export const readYXmlText = decoder => new YXmlText()
--- a/src/utils/AbstractConnector.js
+++ b/src/utils/AbstractConnector.js
@@ -1,26 +0,0 @@
-
-import { Observable } from 'lib0/observable.js'
-
-import {
-  Doc // eslint-disable-line
-} from '../internals.js'
-
-/**
- * This is an abstract interface that all Connectors should implement to keep them interchangeable.
- *
- * @note This interface is experimental and it is not advised to actually inherit this class.
- *       It just serves as typing information.
- *
- * @extends {Observable<any>}
- */
-export class AbstractConnector extends Observable {
-  /**
-   * @param {Doc} ydoc
-   * @param {any} awareness
-   */
-  constructor (ydoc, awareness) {
-    super()
-    this.doc = ydoc
-    this.awareness = awareness
-  }
-}
--- a/src/utils/DeleteSet.js
+++ b/src/utils/DeleteSet.js
@@ -1,323 +0,0 @@
-
-import {
-  findIndexSS,
-  getState,
-  splitItem,
-  iterateStructs,
-  AbstractUpdateDecoder, AbstractDSDecoder, AbstractDSEncoder, DSDecoderV2, DSEncoderV2, Item, GC, StructStore, Transaction, ID // eslint-disable-line
-} from '../internals.js'
-
-import * as array from 'lib0/array.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'
-
-export 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>>}
-     */
-    this.clients = new Map()
-  }
-}
-
-/**
- * Iterate over all structs that the DeleteSet gc's.
- *
- * @param {Transaction} transaction
- * @param {DeleteSet} ds
- * @param {function(GC|Item):void} f
- *
- * @function
- */
-export const iterateDeletedStructs = (transaction, ds, f) =>
-  ds.clients.forEach((deletes, clientid) => {
-    const structs = /** @type {Array<GC|Item>} */ (transaction.doc.store.clients.get(clientid))
-    for (let i = 0; i < deletes.length; i++) {
-      const del = deletes[i]
-      iterateStructs(transaction, structs, del.clock, del.len, f)
-    }
-  })
-
-/**
- * @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 {Array<DeleteSet>} dss
- * @return {DeleteSet} A fresh DeleteSet
- */
-export const mergeDeleteSets = dss => {
-  const merged = new DeleteSet()
-  for (let dssI = 0; dssI < dss.length; dssI++) {
-    dss[dssI].clients.forEach((delsLeft, client) => {
-      if (!merged.clients.has(client)) {
-        // Write all missing keys from current ds and all following.
-        // If merged already contains `client` current ds has already been added.
-        /**
-         * @type {Array<DeleteItem>}
-         */
-        const dels = delsLeft.slice()
-        for (let i = dssI + 1; i < dss.length; i++) {
-          array.appendTo(dels, dss[i].clients.get(client) || [])
-        }
-        merged.clients.set(client, dels)
-      }
-    })
-  }
-  sortAndMergeDeleteSet(merged)
-  return merged
-}
-
-/**
- * @param {DeleteSet} ds
- * @param {number} client
- * @param {number} clock
- * @param {number} length
- *
- * @private
- * @function
- */
-export const addToDeleteSet = (ds, client, clock, length) => {
-  map.setIfUndefined(ds.clients, client, () => []).push(new DeleteItem(clock, length))
-}
-
-export const createDeleteSet = () => new DeleteSet()
-
-/**
- * @param {StructStore} ss
- * @return {DeleteSet} Merged and sorted DeleteSet
- *
- * @private
- * @function
- */
-export const createDeleteSetFromStructStore = ss => {
-  const ds = createDeleteSet()
-  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 {AbstractDSEncoder} encoder
- * @param {DeleteSet} ds
- *
- * @private
- * @function
- */
-export const writeDeleteSet = (encoder, ds) => {
-  encoding.writeVarUint(encoder.restEncoder, ds.clients.size)
-  ds.clients.forEach((dsitems, client) => {
-    encoder.resetDsCurVal()
-    encoding.writeVarUint(encoder.restEncoder, client)
-    const len = dsitems.length
-    encoding.writeVarUint(encoder.restEncoder, len)
-    for (let i = 0; i < len; i++) {
-      const item = dsitems[i]
-      encoder.writeDsClock(item.clock)
-      encoder.writeDsLen(item.len)
-    }
-  })
-}
-
-/**
- * @param {AbstractDSDecoder} decoder
- * @return {DeleteSet}
- *
- * @private
- * @function
- */
-export const readDeleteSet = decoder => {
-  const ds = new DeleteSet()
-  const numClients = decoding.readVarUint(decoder.restDecoder)
-  for (let i = 0; i < numClients; i++) {
-    decoder.resetDsCurVal()
-    const client = decoding.readVarUint(decoder.restDecoder)
-    const numberOfDeletes = decoding.readVarUint(decoder.restDecoder)
-    if (numberOfDeletes > 0) {
-      const dsField = map.setIfUndefined(ds.clients, client, () => [])
-      for (let i = 0; i < numberOfDeletes; i++) {
-        dsField.push(new DeleteItem(decoder.readDsClock(), decoder.readDsLen()))
-      }
-    }
-  }
-  return ds
-}
-
-/**
- * @todo YDecoder also contains references to String and other Decoders. Would make sense to exchange YDecoder.toUint8Array for YDecoder.DsToUint8Array()..
- */
-
-/**
- * @param {AbstractDSDecoder} decoder
- * @param {Transaction} transaction
- * @param {StructStore} store
- *
- * @private
- * @function
- */
-export const readAndApplyDeleteSet = (decoder, transaction, store) => {
-  const unappliedDS = new DeleteSet()
-  const numClients = decoding.readVarUint(decoder.restDecoder)
-  for (let i = 0; i < numClients; i++) {
-    decoder.resetDsCurVal()
-    const client = decoding.readVarUint(decoder.restDecoder)
-    const numberOfDeletes = decoding.readVarUint(decoder.restDecoder)
-    const structs = store.clients.get(client) || []
-    const state = getState(store, client)
-    for (let i = 0; i < numberOfDeletes; i++) {
-      const clock = decoder.readDsClock()
-      const clockEnd = clock + decoder.readDsLen()
-      if (clock < state) {
-        if (state < clockEnd) {
-          addToDeleteSet(unappliedDS, client, state, clockEnd - state)
-        }
-        let index = findIndexSS(structs, clock)
-        /**
-         * We can ignore the case of GC and Delete structs, because we are going to skip them
-         * @type {Item}
-         */
-        // @ts-ignore
-        let struct = structs[index]
-        // split the first item if necessary
-        if (!struct.deleted && struct.id.clock < clock) {
-          structs.splice(index + 1, 0, splitItem(transaction, struct, 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 < clockEnd) {
-            if (!struct.deleted) {
-              if (clockEnd < struct.id.clock + struct.length) {
-                structs.splice(index, 0, splitItem(transaction, struct, clockEnd - struct.id.clock))
-              }
-              struct.delete(transaction)
-            }
-          } else {
-            break
-          }
-        }
-      } else {
-        addToDeleteSet(unappliedDS, client, clock, clockEnd - clock)
-      }
-    }
-  }
-  if (unappliedDS.clients.size > 0) {
-    // TODO: no need for encoding+decoding ds anymore
-    const unappliedDSEncoder = new DSEncoderV2()
-    writeDeleteSet(unappliedDSEncoder, unappliedDS)
-    store.pendingDeleteReaders.push(new DSDecoderV2(decoding.createDecoder((unappliedDSEncoder.toUint8Array()))))
-  }
-}
--- a/src/utils/Doc.js
+++ b/src/utils/Doc.js
@@ -1,213 +0,0 @@
-/**
- * @module Y
- */
-
-import {
-  StructStore,
-  AbstractType,
-  YArray,
-  YText,
-  YMap,
-  YXmlFragment,
-  transact,
-  Item, 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'
-
-export const generateNewClientId = random.uint32
-
-/**
- * A Yjs instance handles the state of shared data.
- * @extends Observable<string>
- */
-export class Doc extends Observable {
-  /**
-   * @param {Object} conf configuration
-   * @param {boolean} [conf.gc] Disable garbage collection (default: gc=true)
-   * @param {function(Item):boolean} [conf.gcFilter] Will be called before an Item is garbage collected. Return false to keep the Item.
-   */
-  constructor ({ gc = true, gcFilter = () => true } = {}) {
-    super()
-    this.gc = gc
-    this.gcFilter = gcFilter
-    this.clientID = generateNewClientId()
-    /**
-     * @type {Map<string, AbstractType<YEvent>>}
-     */
-    this.share = new Map()
-    this.store = new StructStore()
-    /**
-     * @type {Transaction | null}
-     */
-    this._transaction = null
-    /**
-     * @type {Array<Transaction>}
-     */
-    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 {Item?} n */ n => {
-          for (; n !== null; n = n.left) {
-            // @ts-ignore
-            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)
-  }
-
-  /**
-   * Converts the entire document into a js object, recursively traversing each yjs type
-   *
-   * @return {Object<string, any>}
-   */
-  toJSON () {
-    /**
-     * @type {Object<string, any>}
-     */
-    const doc = {}
-
-    this.share.forEach((value, key) => {
-      doc[key] = value.toJSON()
-    })
-
-    return doc
-  }
-
-  /**
-   * Emit `destroy` event and unregister all event handlers.
-   */
-  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
@@ -1,82 +0,0 @@
-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
@@ -1,90 +0,0 @@
-
-import { AbstractType } from '../internals.js' // 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 (const [key, value] of type.doc.share.entries()) {
-    if (value === type) {
-      return key
-    }
-  }
-  throw error.unexpectedCase()
-}
--- a/src/utils/PermanentUserData.js
+++ b/src/utils/PermanentUserData.js
@@ -1,142 +0,0 @@
-
-import {
-  YArray,
-  YMap,
-  readDeleteSet,
-  writeDeleteSet,
-  createDeleteSet,
-  DSEncoderV1, DSDecoderV1, ID, DeleteSet, YArrayEvent, Transaction, Doc // eslint-disable-line
-} from '../internals.js'
-
-import * as decoding from 'lib0/decoding.js'
-
-import { mergeDeleteSets, isDeleted } from './DeleteSet.js'
-
-export class PermanentUserData {
-  /**
-   * @param {Doc} doc
-   * @param {YMap<any>} [storeType]
-   */
-  constructor (doc, storeType = doc.getMap('users')) {
-    /**
-     * @type {Map<string,DeleteSet>}
-     */
-    const dss = new Map()
-    this.yusers = storeType
-    this.doc = doc
-    /**
-     * Maps from clientid to userDescription
-     *
-     * @type {Map<number,string>}
-     */
-    this.clients = new Map()
-    this.dss = dss
-    /**
-     * @param {YMap<any>} user
-     * @param {string} userDescription
-     */
-    const initUser = (user, userDescription) => {
-      /**
-       * @type {YArray<Uint8Array>}
-       */
-      const ds = user.get('ds')
-      const ids = user.get('ids')
-      const addClientId = /** @param {number} clientid */ clientid => this.clients.set(clientid, userDescription)
-      ds.observe(/** @param {YArrayEvent<any>} event */ event => {
-        event.changes.added.forEach(item => {
-          item.content.getContent().forEach(encodedDs => {
-            if (encodedDs instanceof Uint8Array) {
-              this.dss.set(userDescription, mergeDeleteSets([this.dss.get(userDescription) || createDeleteSet(), readDeleteSet(new DSDecoderV1(decoding.createDecoder(encodedDs)))]))
-            }
-          })
-        })
-      })
-      this.dss.set(userDescription, mergeDeleteSets(ds.map(encodedDs => readDeleteSet(new DSDecoderV1(encodedDs)))))
-      ids.observe(/** @param {YArrayEvent<any>} event */ event =>
-        event.changes.added.forEach(item => item.content.getContent().forEach(addClientId))
-      )
-      ids.forEach(addClientId)
-    }
-    // observe users
-    storeType.observe(event => {
-      event.keysChanged.forEach(userDescription =>
-        initUser(storeType.get(userDescription), userDescription)
-      )
-    })
-    // add intial data
-    storeType.forEach(initUser)
-  }
-
-  /**
-   * @param {Doc} doc
-   * @param {number} clientid
-   * @param {string} userDescription
-   * @param {Object} [conf]
-   * @param {function(Transaction, DeleteSet):boolean} [conf.filter]
-   */
-  setUserMapping (doc, clientid, userDescription, { filter = () => true } = {}) {
-    const users = this.yusers
-    let user = users.get(userDescription)
-    if (!user) {
-      user = new YMap()
-      user.set('ids', new YArray())
-      user.set('ds', new YArray())
-      users.set(userDescription, user)
-    }
-    user.get('ids').push([clientid])
-    users.observe(event => {
-      setTimeout(() => {
-        const userOverwrite = users.get(userDescription)
-        if (userOverwrite !== user) {
-          // user was overwritten, port all data over to the next user object
-          // @todo Experiment with Y.Sets here
-          user = userOverwrite
-          // @todo iterate over old type
-          this.clients.forEach((_userDescription, clientid) => {
-            if (userDescription === _userDescription) {
-              user.get('ids').push([clientid])
-            }
-          })
-          const encoder = new DSEncoderV1()
-          const ds = this.dss.get(userDescription)
-          if (ds) {
-            writeDeleteSet(encoder, ds)
-            user.get('ds').push([encoder.toUint8Array()])
-          }
-        }
-      }, 0)
-    })
-    doc.on('afterTransaction', /** @param {Transaction} transaction */ transaction => {
-      setTimeout(() => {
-        const yds = user.get('ds')
-        const ds = transaction.deleteSet
-        if (transaction.local && ds.clients.size > 0 && filter(transaction, ds)) {
-          const encoder = new DSEncoderV1()
-          writeDeleteSet(encoder, ds)
-          yds.push([encoder.toUint8Array()])
-        }
-      })
-    })
-  }
-
-  /**
-   * @param {number} clientid
-   * @return {any}
-   */
-  getUserByClientId (clientid) {
-    return this.clients.get(clientid) || null
-  }
-
-  /**
-   * @param {ID} id
-   * @return {string | null}
-   */
-  getUserByDeletedId (id) {
-    for (const [userDescription, ds] of this.dss.entries()) {
-      if (isDeleted(ds, id)) {
-        return userDescription
-      }
-    }
-    return null
-  }
-}
--- a/src/utils/RelativePosition.js
+++ b/src/utils/RelativePosition.js
@@ -1,272 +0,0 @@
-
-import {
-  writeID,
-  readID,
-  compareIDs,
-  getState,
-  findRootTypeKey,
-  Item,
-  createID,
-  ContentType,
-  followRedone,
-  ID, 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 {any} 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 = createID(type._item.id.client, type._item.id.clock)
-  }
-  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 res = followRedone(store, rightID)
-    const right = res.item
-    if (!(right instanceof Item)) {
-      return null
-    }
-    type = /** @type {AbstractType<any>} */ (right.parent)
-    if (type._item === null || !type._item.deleted) {
-      index = right.deleted || !right.countable ? 0 : res.diff
-      let n = right.left
-      while (n !== null) {
-        if (!n.deleted && n.countable) {
-          index += n.length
-        }
-        n = n.left
-      }
-    }
-  } 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 { item } = followRedone(store, typeID)
-      if (item instanceof Item && item.content instanceof ContentType) {
-        type = item.content.type
-      } else {
-        // struct is garbage collected
-        return null
-      }
-    } else {
-      throw error.unexpectedCase()
-    }
-    index = type._length
-  }
-  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
@@ -1,150 +0,0 @@
-
-import {
-  isDeleted,
-  createDeleteSetFromStructStore,
-  getStateVector,
-  getItemCleanStart,
-  iterateDeletedStructs,
-  writeDeleteSet,
-  writeStateVector,
-  readDeleteSet,
-  readStateVector,
-  createDeleteSet,
-  createID,
-  getState,
-  AbstractDSDecoder, AbstractDSEncoder, DSEncoderV1, DSEncoderV2, DSDecoderV1, DSDecoderV2, Transaction, Doc, DeleteSet, Item // eslint-disable-line
-} from '../internals.js'
-
-import * as map from 'lib0/map.js'
-import * as set from 'lib0/set.js'
-import * as decoding from 'lib0/decoding.js'
-import { DefaultDSEncoder } from './encoding.js'
-
-export class Snapshot {
-  /**
-   * @param {DeleteSet} ds
-   * @param {Map<number,number>} sv state map
-   */
-  constructor (ds, sv) {
-    /**
-     * @type {DeleteSet}
-     */
-    this.ds = ds
-    /**
-     * State Map
-     * @type {Map<number,number>}
-     */
-    this.sv = sv
-  }
-}
-
-/**
- * @param {Snapshot} snap1
- * @param {Snapshot} snap2
- * @return {boolean}
- */
-export const equalSnapshots = (snap1, snap2) => {
-  const ds1 = snap1.ds.clients
-  const ds2 = snap2.ds.clients
-  const sv1 = snap1.sv
-  const sv2 = snap2.sv
-  if (sv1.size !== sv2.size || ds1.size !== ds2.size) {
-    return false
-  }
-  for (const [key, value] of sv1.entries()) {
-    if (sv2.get(key) !== value) {
-      return false
-    }
-  }
-  for (const [client, dsitems1] of ds1.entries()) {
-    const dsitems2 = ds2.get(client) || []
-    if (dsitems1.length !== dsitems2.length) {
-      return false
-    }
-    for (let i = 0; i < dsitems1.length; i++) {
-      const dsitem1 = dsitems1[i]
-      const dsitem2 = dsitems2[i]
-      if (dsitem1.clock !== dsitem2.clock || dsitem1.len !== dsitem2.len) {
-        return false
-      }
-    }
-  }
-  return true
-}
-
-/**
- * @param {Snapshot} snapshot
- * @param {AbstractDSEncoder} [encoder]
- * @return {Uint8Array}
- */
-export const encodeSnapshotV2 = (snapshot, encoder = new DSEncoderV2()) => {
-  writeDeleteSet(encoder, snapshot.ds)
-  writeStateVector(encoder, snapshot.sv)
-  return encoder.toUint8Array()
-}
-
-/**
- * @param {Snapshot} snapshot
- * @return {Uint8Array}
- */
-export const encodeSnapshot = snapshot => encodeSnapshotV2(snapshot, new DefaultDSEncoder())
-
-/**
- * @param {Uint8Array} buf
- * @param {AbstractDSDecoder} [decoder]
- * @return {Snapshot}
- */
-export const decodeSnapshotV2 = (buf, decoder = new DSDecoderV2(decoding.createDecoder(buf))) => {
-  return new Snapshot(readDeleteSet(decoder), readStateVector(decoder))
-}
-
-/**
- * @param {Uint8Array} buf
- * @return {Snapshot}
- */
-export const decodeSnapshot = buf => decodeSnapshotV2(buf, new DSDecoderV1(decoding.createDecoder(buf)))
-
-/**
- * @param {DeleteSet} ds
- * @param {Map<number,number>} sm
- * @return {Snapshot}
- */
-export const createSnapshot = (ds, sm) => new Snapshot(ds, sm)
-
-export const emptySnapshot = createSnapshot(createDeleteSet(), new Map())
-
-/**
- * @param {Doc} doc
- * @return {Snapshot}
- */
-export const snapshot = doc => createSnapshot(createDeleteSetFromStructStore(doc.store), getStateVector(doc.store))
-
-/**
- * @param {Item} item
- * @param {Snapshot|undefined} snapshot
- *
- * @protected
- * @function
- */
-export const isVisible = (item, snapshot) => snapshot === undefined ? !item.deleted : (
-  snapshot.sv.has(item.id.client) && (snapshot.sv.get(item.id.client) || 0) > item.id.clock && !isDeleted(snapshot.ds, item.id)
-)
-
-/**
- * @param {Transaction} transaction
- * @param {Snapshot} snapshot
- */
-export const splitSnapshotAffectedStructs = (transaction, snapshot) => {
-  const meta = map.setIfUndefined(transaction.meta, splitSnapshotAffectedStructs, set.create)
-  const store = transaction.doc.store
-  // check if we already split for this snapshot
-  if (!meta.has(snapshot)) {
-    snapshot.sv.forEach((clock, client) => {
-      if (clock < getState(store, client)) {
-        getItemCleanStart(transaction, createID(client, clock))
-      }
-    })
-    iterateDeletedStructs(transaction, snapshot.ds, item => {})
-    meta.add(snapshot)
-  }
-}
--- a/src/utils/StructStore.js
+++ b/src/utils/StructStore.js
@@ -1,273 +0,0 @@
-
-import {
-  GC,
-  splitItem,
-  Transaction, ID, Item, DSDecoderV2 // eslint-disable-line
-} from '../internals.js'
-
-import * as math from 'lib0/math.js'
-import * as error from 'lib0/error.js'
-
-export class StructStore {
-  constructor () {
-    /**
-     * @type {Map<number,Array<GC|Item>>}
-     */
-    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<GC|Item>}>}
-     */
-    this.pendingClientsStructRefs = new Map()
-    /**
-     * Stack of pending structs waiting for struct dependencies
-     * Maximum length of stack is structReaders.size
-     * @type {Array<GC|Item>}
-     */
-    this.pendingStack = []
-    /**
-     * @type {Array<DSDecoderV2>}
-     */
-    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 {GC|Item} 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<Item|GC>} structs
- * @param {number} clock
- * @return {number}
- *
- * @private
- * @function
- */
-export const findIndexSS = (structs, clock) => {
-  let left = 0
-  let right = structs.length - 1
-  let mid = structs[right]
-  let midclock = mid.id.clock
-  if (midclock === clock) {
-    return right
-  }
-  // @todo does it even make sense to pivot the search?
-  // If a good split misses, it might actually increase the time to find the correct item.
-  // Currently, the only advantage is that search with pivoting might find the item on the first try.
-  let midindex = math.floor((clock / (midclock + mid.length - 1)) * right) // pivoting the search
-  while (left <= right) {
-    mid = structs[midindex]
-    midclock = mid.id.clock
-    if (midclock <= clock) {
-      if (clock < midclock + mid.length) {
-        return midindex
-      }
-      left = midindex + 1
-    } else {
-      right = midindex - 1
-    }
-    midindex = math.floor((left + right) / 2)
-  }
-  // 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 {GC|Item}
- *
- * @private
- * @function
- */
-export const find = (store, id) => {
-  /**
-   * @type {Array<GC|Item>}
-   */
-  // @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.
- * @private
- * @function
- */
-export const getItem = /** @type {function(StructStore,ID):Item} */ (find)
-
-/**
- * @param {Transaction} transaction
- * @param {Array<Item|GC>} structs
- * @param {number} clock
- */
-export const findIndexCleanStart = (transaction, structs, clock) => {
-  const index = findIndexSS(structs, clock)
-  const struct = structs[index]
-  if (struct.id.clock < clock && struct instanceof Item) {
-    structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock))
-    return index + 1
-  }
-  return index
-}
-
-/**
- * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
- *
- * @param {Transaction} transaction
- * @param {ID} id
- * @return {Item}
- *
- * @private
- * @function
- */
-export const getItemCleanStart = (transaction, id) => {
-  const structs = /** @type {Array<Item>} */ (transaction.doc.store.clients.get(id.client))
-  return structs[findIndexCleanStart(transaction, structs, id.clock)]
-}
-
-/**
- * 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 {Item}
- *
- * @private
- * @function
- */
-export const getItemCleanEnd = (transaction, store, id) => {
-  /**
-   * @type {Array<Item>}
-   */
-  // @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, splitItem(transaction, struct, id.clock - struct.id.clock + 1))
-  }
-  return struct
-}
-
-/**
- * Replace `item` with `newitem` in store
- * @param {StructStore} store
- * @param {GC|Item} struct
- * @param {GC|Item} newStruct
- *
- * @private
- * @function
- */
-export const replaceStruct = (store, struct, newStruct) => {
-  const structs = /** @type {Array<GC|Item>} */ (store.clients.get(struct.id.client))
-  structs[findIndexSS(structs, struct.id.clock)] = newStruct
-}
-
-/**
- * Iterate over a range of structs
- *
- * @param {Transaction} transaction
- * @param {Array<Item|GC>} structs
- * @param {number} clockStart Inclusive start
- * @param {number} len
- * @param {function(GC|Item):void} f
- *
- * @function
- */
-export const iterateStructs = (transaction, structs, clockStart, len, f) => {
-  if (len === 0) {
-    return
-  }
-  const clockEnd = clockStart + len
-  let index = findIndexCleanStart(transaction, structs, clockStart)
-  let struct
-  do {
-    struct = structs[index++]
-    if (clockEnd < struct.id.clock + struct.length) {
-      findIndexCleanStart(transaction, structs, clockEnd)
-    }
-    f(struct)
-  } while (index < structs.length && structs[index].id.clock < clockEnd)
-}
--- a/src/utils/Transaction.js
+++ b/src/utils/Transaction.js
@@ -1,384 +0,0 @@
-
-import {
-  getState,
-  writeStructsFromTransaction,
-  writeDeleteSet,
-  DeleteSet,
-  sortAndMergeDeleteSet,
-  getStateVector,
-  findIndexSS,
-  callEventHandlerListeners,
-  Item,
-  generateNewClientId,
-  createID,
-  AbstractUpdateEncoder, GC, StructStore, UpdateEncoderV2, DefaultUpdateEncoder, AbstractType, AbstractStruct, YEvent, Doc // eslint-disable-line
-} from '../internals.js'
-
-import * as map from 'lib0/map.js'
-import * as math from 'lib0/math.js'
-import * as set from 'lib0/set.js'
-import * as logging from 'lib0/logging.js'
-import { callAll } from 'lib0/function.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
-   * @param {boolean} local
-   */
-  constructor (doc, origin, local) {
-    /**
-     * 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 {Array<AbstractStruct>}
-     */
-    this._mergeStructs = []
-    /**
-     * @type {any}
-     */
-    this.origin = origin
-    /**
-     * Stores meta information on the transaction
-     * @type {Map<any,any>}
-     */
-    this.meta = new Map()
-    /**
-     * Whether this change originates from this doc.
-     * @type {boolean}
-     */
-    this.local = local
-  }
-}
-
-/**
- * @param {AbstractUpdateEncoder} encoder
- * @param {Transaction} transaction
- * @return {boolean} Whether data was written.
- */
-export const writeUpdateMessageFromTransaction = (encoder, transaction) => {
-  if (transaction.deleteSet.clients.size === 0 && !map.any(transaction.afterState, (clock, client) => transaction.beforeState.get(client) !== clock)) {
-    return false
-  }
-  sortAndMergeDeleteSet(transaction.deleteSet)
-  writeStructsFromTransaction(encoder, transaction)
-  writeDeleteSet(encoder, transaction.deleteSet)
-  return true
-}
-
-/**
- * @param {Transaction} transaction
- *
- * @private
- * @function
- */
-export const nextID = transaction => {
-  const y = transaction.doc
-  return createID(y.clientID, getState(y.store, y.clientID))
-}
-
-/**
- * If `type.parent` was added in current transaction, `type` technically
- * did not change, it was just added and we should not fire events for `type`.
- *
- * @param {Transaction} transaction
- * @param {AbstractType<YEvent>} type
- * @param {string|null} parentSub
- */
-export const addChangedTypeToTransaction = (transaction, type, parentSub) => {
-  const item = type._item
-  if (item === null || (item.id.clock < (transaction.beforeState.get(item.id.client) || 0) && !item.deleted)) {
-    map.setIfUndefined(transaction.changed, type, set.create).add(parentSub)
-  }
-}
-
-/**
- * @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 Item && right.parentSub !== null && /** @type {AbstractType<any>} */ (right.parent)._map.get(right.parentSub) === right) {
-        /** @type {AbstractType<any>} */ (right.parent)._map.set(right.parentSub, /** @type {Item} */ (left))
-      }
-    }
-  }
-}
-
-/**
- * @param {DeleteSet} ds
- * @param {StructStore} store
- * @param {function(Item):boolean} gcFilter
- */
-const tryGcDeleteSet = (ds, store, gcFilter) => {
-  for (const [client, deleteItems] of ds.clients.entries()) {
-    const structs = /** @type {Array<GC|Item>} */ (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 instanceof Item && struct.deleted && !struct.keep && gcFilter(struct)) {
-          struct.gc(store, false)
-        }
-      }
-    }
-  }
-}
-
-/**
- * @param {DeleteSet} ds
- * @param {StructStore} store
- */
-const tryMergeDeleteSet = (ds, store) => {
-  // try to merge deleted / gc'd items
-  // merge from right to left for better efficiecy and so we don't miss any merge targets
-  ds.clients.forEach((deleteItems, client) => {
-    const structs = /** @type {Array<GC|Item>} */ (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)
-      }
-    }
-  })
-}
-
-/**
- * @param {DeleteSet} ds
- * @param {StructStore} store
- * @param {function(Item):boolean} gcFilter
- */
-export const tryGc = (ds, store, gcFilter) => {
-  tryGcDeleteSet(ds, store, gcFilter)
-  tryMergeDeleteSet(ds, store)
-}
-
-/**
- * @param {Array<Transaction>} transactionCleanups
- * @param {number} i
- */
-const cleanupTransactions = (transactionCleanups, i) => {
-  if (i < transactionCleanups.length) {
-    const transaction = transactionCleanups[i]
-    const doc = transaction.doc
-    const store = doc.store
-    const ds = transaction.deleteSet
-    const mergeStructs = transaction._mergeStructs
-    try {
-      sortAndMergeDeleteSet(ds)
-      transaction.afterState = getStateVector(transaction.doc.store)
-      doc._transaction = null
-      doc.emit('beforeObserverCalls', [transaction, doc])
-      /**
-       * An array of event callbacks.
-       *
-       * Each callback is called even if the other ones throw errors.
-       *
-       * @type {Array<function():void>}
-       */
-      const fs = []
-      // observe events on changed types
-      transaction.changed.forEach((subs, itemtype) =>
-        fs.push(() => {
-          if (itemtype._item === null || !itemtype._item.deleted) {
-            itemtype._callObserver(transaction, subs)
-          }
-        })
-      )
-      fs.push(() => {
-        // deep observe events
-        transaction.changedParentTypes.forEach((events, type) =>
-          fs.push(() => {
-            // We need to think about the possibility that the user transforms the
-            // Y.Doc in the event.
-            if (type._item === null || !type._item.deleted) {
-              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)
-            }
-          })
-        )
-        fs.push(() => doc.emit('afterTransaction', [transaction, doc]))
-      })
-      callAll(fs, [])
-    } finally {
-      // Replace deleted items with ItemDeleted / GC.
-      // This is where content is actually remove from the Yjs Doc.
-      if (doc.gc) {
-        tryGcDeleteSet(ds, store, doc.gcFilter)
-      }
-      tryMergeDeleteSet(ds, store)
-
-      // on all affected store.clients props, try to merge
-      transaction.afterState.forEach((clock, client) => {
-        const beforeClock = transaction.beforeState.get(client) || 0
-        if (beforeClock !== clock) {
-          const structs = /** @type {Array<GC|Item>} */ (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 (let i = 0; i < mergeStructs.length; i++) {
-        const { client, clock } = mergeStructs[i].id
-        const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client))
-        const replacedStructPos = findIndexSS(structs, clock)
-        if (replacedStructPos + 1 < structs.length) {
-          tryToMergeWithLeft(structs, replacedStructPos + 1)
-        }
-        if (replacedStructPos > 0) {
-          tryToMergeWithLeft(structs, replacedStructPos)
-        }
-      }
-      if (!transaction.local && transaction.afterState.get(doc.clientID) !== transaction.beforeState.get(doc.clientID)) {
-        doc.clientID = generateNewClientId()
-        logging.print(logging.ORANGE, logging.BOLD, '[yjs] ', logging.UNBOLD, logging.RED, 'Changed the client-id because another client seems to be using it.')
-      }
-      // @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 encoder = new DefaultUpdateEncoder()
-        const hasContent = writeUpdateMessageFromTransaction(encoder, transaction)
-        if (hasContent) {
-          doc.emit('update', [encoder.toUint8Array(), transaction.origin, doc])
-        }
-      }
-      if (doc._observers.has('updateV2')) {
-        const encoder = new UpdateEncoderV2()
-        const hasContent = writeUpdateMessageFromTransaction(encoder, transaction)
-        if (hasContent) {
-          doc.emit('updateV2', [encoder.toUint8Array(), transaction.origin, doc])
-        }
-      }
-      if (transactionCleanups.length <= i + 1) {
-        doc._transactionCleanups = []
-        doc.emit('afterAllTransactions', [doc, transactionCleanups])
-      } else {
-        cleanupTransactions(transactionCleanups, i + 1)
-      }
-    }
-  }
-}
-
-/**
- * Implements the functionality of `y.transact(()=>{..})`
- *
- * @param {Doc} doc
- * @param {function(Transaction):void} f
- * @param {any} [origin=true]
- *
- * @function
- */
-export const transact = (doc, f, origin = null, local = true) => {
-  const transactionCleanups = doc._transactionCleanups
-  let initialCall = false
-  if (doc._transaction === null) {
-    initialCall = true
-    doc._transaction = new Transaction(doc, origin, local)
-    transactionCleanups.push(doc._transaction)
-    if (transactionCleanups.length === 1) {
-      doc.emit('beforeAllTransactions', [doc])
-    }
-    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.
-      // Also we need to ensure that all cleanups are called, even if the
-      // observes throw errors.
-      // This file is full of hacky try {} finally {} blocks to ensure that an
-      // event can throw errors and also that the cleanup is called.
-      cleanupTransactions(transactionCleanups, 0)
-    }
-  }
-}
--- a/src/utils/UndoManager.js
+++ b/src/utils/UndoManager.js
@@ -1,293 +0,0 @@
-import {
-  mergeDeleteSets,
-  iterateDeletedStructs,
-  keepItem,
-  transact,
-  createID,
-  redoItem,
-  iterateStructs,
-  isParentOf,
-  followRedone,
-  getItemCleanStart,
-  getState,
-  ID, Transaction, Doc, Item, GC, DeleteSet, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as time from 'lib0/time.js'
-import { Observable } from 'lib0/observable.js'
-
-class StackItem {
-  /**
-   * @param {DeleteSet} ds
-   * @param {Map<number,number>} beforeState
-   * @param {Map<number,number>} afterState
-   */
-  constructor (ds, beforeState, afterState) {
-    this.ds = ds
-    this.beforeState = beforeState
-    this.afterState = afterState
-    /**
-     * Use this to save and restore metadata like selection range
-     */
-    this.meta = new Map()
-  }
-}
-
-/**
- * @param {UndoManager} undoManager
- * @param {Array<StackItem>} stack
- * @param {string} eventType
- * @return {StackItem?}
- */
-const popStackItem = (undoManager, stack, eventType) => {
-  /**
-   * Whether a change happened
-   * @type {StackItem?}
-   */
-  let result = null
-  const doc = undoManager.doc
-  const scope = undoManager.scope
-  transact(doc, transaction => {
-    while (stack.length > 0 && result === null) {
-      const store = doc.store
-      const stackItem = /** @type {StackItem} */ (stack.pop())
-      /**
-       * @type {Set<Item>}
-       */
-      const itemsToRedo = new Set()
-      /**
-       * @type {Array<Item>}
-       */
-      const itemsToDelete = []
-      let performedChange = false
-      stackItem.afterState.forEach((endClock, client) => {
-        const startClock = stackItem.beforeState.get(client) || 0
-        const len = endClock - startClock
-        // @todo iterateStructs should not need the structs parameter
-        const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client))
-        if (startClock !== endClock) {
-          // make sure structs don't overlap with the range of created operations [stackItem.start, stackItem.start + stackItem.end)
-          // this must be executed before deleted structs are iterated.
-          getItemCleanStart(transaction, createID(client, startClock))
-          if (endClock < getState(doc.store, client)) {
-            getItemCleanStart(transaction, createID(client, endClock))
-          }
-          iterateStructs(transaction, structs, startClock, len, struct => {
-            if (struct instanceof Item) {
-              if (struct.redone !== null) {
-                let { item, diff } = followRedone(store, struct.id)
-                if (diff > 0) {
-                  item = getItemCleanStart(transaction, createID(item.id.client, item.id.clock + diff))
-                }
-                if (item.length > len) {
-                  getItemCleanStart(transaction, createID(item.id.client, endClock))
-                }
-                struct = item
-              }
-              if (!struct.deleted && scope.some(type => isParentOf(type, /** @type {Item} */ (struct)))) {
-                itemsToDelete.push(struct)
-              }
-            }
-          })
-        }
-      })
-      iterateDeletedStructs(transaction, stackItem.ds, struct => {
-        const id = struct.id
-        const clock = id.clock
-        const client = id.client
-        const startClock = stackItem.beforeState.get(client) || 0
-        const endClock = stackItem.afterState.get(client) || 0
-        if (
-          struct instanceof Item &&
-          scope.some(type => isParentOf(type, struct)) &&
-          // Never redo structs in [stackItem.start, stackItem.start + stackItem.end) because they were created and deleted in the same capture interval.
-          !(clock >= startClock && clock < endClock)
-        ) {
-          itemsToRedo.add(struct)
-        }
-      })
-      itemsToRedo.forEach(struct => {
-        performedChange = redoItem(transaction, struct, itemsToRedo) !== null || performedChange
-      })
-      // We want to delete in reverse order so that children are deleted before
-      // parents, so we have more information available when items are filtered.
-      for (let i = itemsToDelete.length - 1; i >= 0; i--) {
-        const item = itemsToDelete[i]
-        if (undoManager.deleteFilter(item)) {
-          item.delete(transaction)
-          performedChange = true
-        }
-      }
-      result = stackItem
-      if (result != null) {
-        undoManager.emit('stack-item-popped', [{ stackItem: result, type: eventType }, undoManager])
-      }
-    }
-  }, undoManager)
-  return result
-}
-
-/**
- * @typedef {Object} UndoManagerOptions
- * @property {number} [UndoManagerOptions.captureTimeout=500]
- * @property {function(Item):boolean} [UndoManagerOptions.deleteFilter=()=>true] Sometimes
- * it is necessary to filter whan an Undo/Redo operation can delete. If this
- * filter returns false, the type/item won't be deleted even it is in the
- * undo/redo scope.
- * @property {Set<any>} [UndoManagerOptions.trackedOrigins=new Set([null])]
- */
-
-/**
- * Fires 'stack-item-added' event when a stack item was added to either the undo- or
- * the redo-stack. You may store additional stack information via the
- * metadata property on `event.stackItem.meta` (it is a `Map` of metadata properties).
- * Fires 'stack-item-popped' event when a stack item was popped from either the
- * undo- or the redo-stack. You may restore the saved stack information from `event.stackItem.meta`.
- *
- * @extends {Observable<'stack-item-added'|'stack-item-popped'>}
- */
-export class UndoManager extends Observable {
-  /**
-   * @param {AbstractType<any>|Array<AbstractType<any>>} typeScope Accepts either a single type, or an array of types
-   * @param {UndoManagerOptions} options
-   */
-  constructor (typeScope, { captureTimeout, deleteFilter = () => true, trackedOrigins = new Set([null]) } = {}) {
-    if (captureTimeout == null) {
-      captureTimeout = 500
-    }
-    super()
-    this.scope = typeScope instanceof Array ? typeScope : [typeScope]
-    this.deleteFilter = deleteFilter
-    trackedOrigins.add(this)
-    this.trackedOrigins = trackedOrigins
-    /**
-     * @type {Array<StackItem>}
-     */
-    this.undoStack = []
-    /**
-     * @type {Array<StackItem>}
-     */
-    this.redoStack = []
-    /**
-     * Whether the client is currently undoing (calling UndoManager.undo)
-     *
-     * @type {boolean}
-     */
-    this.undoing = false
-    this.redoing = false
-    this.doc = /** @type {Doc} */ (this.scope[0].doc)
-    this.lastChange = 0
-    this.doc.on('afterTransaction', /** @param {Transaction} transaction */ transaction => {
-      // Only track certain transactions
-      if (!this.scope.some(type => transaction.changedParentTypes.has(type)) || (!this.trackedOrigins.has(transaction.origin) && (!transaction.origin || !this.trackedOrigins.has(transaction.origin.constructor)))) {
-        return
-      }
-      const undoing = this.undoing
-      const redoing = this.redoing
-      const stack = undoing ? this.redoStack : this.undoStack
-      if (undoing) {
-        this.stopCapturing() // next undo should not be appended to last stack item
-      } else if (!redoing) {
-        // neither undoing nor redoing: delete redoStack
-        this.redoStack = []
-      }
-      const beforeState = transaction.beforeState
-      const afterState = transaction.afterState
-      const now = time.getUnixTime()
-      if (now - this.lastChange < captureTimeout && stack.length > 0 && !undoing && !redoing) {
-        // append change to last stack op
-        const lastOp = stack[stack.length - 1]
-        lastOp.ds = mergeDeleteSets([lastOp.ds, transaction.deleteSet])
-        lastOp.afterState = afterState
-      } else {
-        // create a new stack op
-        stack.push(new StackItem(transaction.deleteSet, beforeState, afterState))
-      }
-      if (!undoing && !redoing) {
-        this.lastChange = now
-      }
-      // make sure that deleted structs are not gc'd
-      iterateDeletedStructs(transaction, transaction.deleteSet, /** @param {Item|GC} item */ item => {
-        if (item instanceof Item && this.scope.some(type => isParentOf(type, item))) {
-          keepItem(item, true)
-        }
-      })
-      this.emit('stack-item-added', [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? 'redo' : 'undo' }, this])
-    })
-  }
-
-  clear () {
-    this.doc.transact(transaction => {
-      /**
-       * @param {StackItem} stackItem
-       */
-      const clearItem = stackItem => {
-        iterateDeletedStructs(transaction, stackItem.ds, item => {
-          if (item instanceof Item && this.scope.some(type => isParentOf(type, item))) {
-            keepItem(item, false)
-          }
-        })
-      }
-      this.undoStack.forEach(clearItem)
-      this.redoStack.forEach(clearItem)
-    })
-    this.undoStack = []
-    this.redoStack = []
-  }
-
-  /**
-   * UndoManager merges Undo-StackItem if they are created within time-gap
-   * smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
-   * StackItem won't be merged.
-   *
-   *
-   * @example
-   *     // without stopCapturing
-   *     ytext.insert(0, 'a')
-   *     ytext.insert(1, 'b')
-   *     um.undo()
-   *     ytext.toString() // => '' (note that 'ab' was removed)
-   *     // with stopCapturing
-   *     ytext.insert(0, 'a')
-   *     um.stopCapturing()
-   *     ytext.insert(0, 'b')
-   *     um.undo()
-   *     ytext.toString() // => 'a' (note that only 'b' was removed)
-   *
-   */
-  stopCapturing () {
-    this.lastChange = 0
-  }
-
-  /**
-   * Undo last changes on type.
-   *
-   * @return {StackItem?} Returns StackItem if a change was applied
-   */
-  undo () {
-    this.undoing = true
-    let res
-    try {
-      res = popStackItem(this, this.undoStack, 'undo')
-    } finally {
-      this.undoing = false
-    }
-    return res
-  }
-
-  /**
-   * Redo last undo operation.
-   *
-   * @return {StackItem?} Returns StackItem if a change was applied
-   */
-  redo () {
-    this.redoing = true
-    let res
-    try {
-      res = popStackItem(this, this.redoStack, 'redo')
-    } finally {
-      this.redoing = false
-    }
-    return res
-  }
-}
--- a/src/utils/UpdateDecoder.js
+++ b/src/utils/UpdateDecoder.js
@@ -1,392 +0,0 @@
-import * as buffer from 'lib0/buffer.js'
-import * as error from 'lib0/error.js'
-import * as decoding from 'lib0/decoding.js'
-import {
-  ID, createID
-} from '../internals.js'
-
-export class AbstractDSDecoder {
-  /**
-   * @param {decoding.Decoder} decoder
-   */
-  constructor (decoder) {
-    this.restDecoder = decoder
-    error.methodUnimplemented()
-  }
-
-  resetDsCurVal () { }
-
-  /**
-   * @return {number}
-   */
-  readDsClock () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {number}
-   */
-  readDsLen () {
-    error.methodUnimplemented()
-  }
-}
-
-export class AbstractUpdateDecoder extends AbstractDSDecoder {
-  /**
-   * @return {ID}
-   */
-  readLeftID () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {ID}
-   */
-  readRightID () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * Read the next client id.
-   * Use this in favor of readID whenever possible to reduce the number of objects created.
-   *
-   * @return {number}
-   */
-  readClient () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {number} info An unsigned 8-bit integer
-   */
-  readInfo () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {string}
-   */
-  readString () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {boolean} isKey
-   */
-  readParentInfo () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {number} info An unsigned 8-bit integer
-   */
-  readTypeRef () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @return {number} len
-   */
-  readLen () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {any}
-   */
-  readAny () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {Uint8Array}
-   */
-  readBuf () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * Legacy implementation uses JSON parse. We use any-decoding in v2.
-   *
-   * @return {any}
-   */
-  readJSON () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {string}
-   */
-  readKey () {
-    error.methodUnimplemented()
-  }
-}
-
-export class DSDecoderV1 {
-  /**
-   * @param {decoding.Decoder} decoder
-   */
-  constructor (decoder) {
-    this.restDecoder = decoder
-  }
-
-  resetDsCurVal () {
-    // nop
-  }
-
-  /**
-   * @return {number}
-   */
-  readDsClock () {
-    return decoding.readVarUint(this.restDecoder)
-  }
-
-  /**
-   * @return {number}
-   */
-  readDsLen () {
-    return decoding.readVarUint(this.restDecoder)
-  }
-}
-
-export class UpdateDecoderV1 extends DSDecoderV1 {
-  /**
-   * @return {ID}
-   */
-  readLeftID () {
-    return createID(decoding.readVarUint(this.restDecoder), decoding.readVarUint(this.restDecoder))
-  }
-
-  /**
-   * @return {ID}
-   */
-  readRightID () {
-    return createID(decoding.readVarUint(this.restDecoder), decoding.readVarUint(this.restDecoder))
-  }
-
-  /**
-   * Read the next client id.
-   * Use this in favor of readID whenever possible to reduce the number of objects created.
-   */
-  readClient () {
-    return decoding.readVarUint(this.restDecoder)
-  }
-
-  /**
-   * @return {number} info An unsigned 8-bit integer
-   */
-  readInfo () {
-    return decoding.readUint8(this.restDecoder)
-  }
-
-  /**
-   * @return {string}
-   */
-  readString () {
-    return decoding.readVarString(this.restDecoder)
-  }
-
-  /**
-   * @return {boolean} isKey
-   */
-  readParentInfo () {
-    return decoding.readVarUint(this.restDecoder) === 1
-  }
-
-  /**
-   * @return {number} info An unsigned 8-bit integer
-   */
-  readTypeRef () {
-    return decoding.readVarUint(this.restDecoder)
-  }
-
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @return {number} len
-   */
-  readLen () {
-    return decoding.readVarUint(this.restDecoder)
-  }
-
-  /**
-   * @return {any}
-   */
-  readAny () {
-    return decoding.readAny(this.restDecoder)
-  }
-
-  /**
-   * @return {Uint8Array}
-   */
-  readBuf () {
-    return buffer.copyUint8Array(decoding.readVarUint8Array(this.restDecoder))
-  }
-
-  /**
-   * Legacy implementation uses JSON parse. We use any-decoding in v2.
-   *
-   * @return {any}
-   */
-  readJSON () {
-    return JSON.parse(decoding.readVarString(this.restDecoder))
-  }
-
-  /**
-   * @return {string}
-   */
-  readKey () {
-    return decoding.readVarString(this.restDecoder)
-  }
-}
-
-export class DSDecoderV2 {
-  /**
-   * @param {decoding.Decoder} decoder
-   */
-  constructor (decoder) {
-    this.dsCurrVal = 0
-    this.restDecoder = decoder
-  }
-
-  resetDsCurVal () {
-    this.dsCurrVal = 0
-  }
-
-  readDsClock () {
-    this.dsCurrVal += decoding.readVarUint(this.restDecoder)
-    return this.dsCurrVal
-  }
-
-  readDsLen () {
-    const diff = decoding.readVarUint(this.restDecoder) + 1
-    this.dsCurrVal += diff
-    return diff
-  }
-}
-
-export class UpdateDecoderV2 extends DSDecoderV2 {
-  /**
-   * @param {decoding.Decoder} decoder
-   */
-  constructor (decoder) {
-    super(decoder)
-    /**
-     * List of cached keys. If the keys[id] does not exist, we read a new key
-     * from stringEncoder and push it to keys.
-     *
-     * @type {Array<string>}
-     */
-    this.keys = []
-    decoding.readUint8(decoder) // read feature flag - currently unused
-    this.keyClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder))
-    this.clientDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder))
-    this.leftClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder))
-    this.rightClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder))
-    this.infoDecoder = new decoding.RleDecoder(decoding.readVarUint8Array(decoder), decoding.readUint8)
-    this.stringDecoder = new decoding.StringDecoder(decoding.readVarUint8Array(decoder))
-    this.parentInfoDecoder = new decoding.RleDecoder(decoding.readVarUint8Array(decoder), decoding.readUint8)
-    this.typeRefDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder))
-    this.lenDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder))
-  }
-
-  /**
-   * @return {ID}
-   */
-  readLeftID () {
-    return new ID(this.clientDecoder.read(), this.leftClockDecoder.read())
-  }
-
-  /**
-   * @return {ID}
-   */
-  readRightID () {
-    return new ID(this.clientDecoder.read(), this.rightClockDecoder.read())
-  }
-
-  /**
-   * Read the next client id.
-   * Use this in favor of readID whenever possible to reduce the number of objects created.
-   */
-  readClient () {
-    return this.clientDecoder.read()
-  }
-
-  /**
-   * @return {number} info An unsigned 8-bit integer
-   */
-  readInfo () {
-    return /** @type {number} */ (this.infoDecoder.read())
-  }
-
-  /**
-   * @return {string}
-   */
-  readString () {
-    return this.stringDecoder.read()
-  }
-
-  /**
-   * @return {boolean}
-   */
-  readParentInfo () {
-    return this.parentInfoDecoder.read() === 1
-  }
-
-  /**
-   * @return {number} An unsigned 8-bit integer
-   */
-  readTypeRef () {
-    return this.typeRefDecoder.read()
-  }
-
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @return {number}
-   */
-  readLen () {
-    return this.lenDecoder.read()
-  }
-
-  /**
-   * @return {any}
-   */
-  readAny () {
-    return decoding.readAny(this.restDecoder)
-  }
-
-  /**
-   * @return {Uint8Array}
-   */
-  readBuf () {
-    return decoding.readVarUint8Array(this.restDecoder)
-  }
-
-  /**
-   * This is mainly here for legacy purposes.
-   *
-   * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
-   *
-   * @return {any}
-   */
-  readJSON () {
-    return decoding.readAny(this.restDecoder)
-  }
-
-  /**
-   * @return {string}
-   */
-  readKey () {
-    const keyClock = this.keyClockDecoder.read()
-    if (keyClock < this.keys.length) {
-      return this.keys[keyClock]
-    } else {
-      const key = this.stringDecoder.read()
-      this.keys.push(key)
-      return key
-    }
-  }
-}
--- a/src/utils/UpdateEncoder.js
+++ b/src/utils/UpdateEncoder.js
@@ -1,408 +0,0 @@
-
-import * as error from 'lib0/error.js'
-import * as encoding from 'lib0/encoding.js'
-
-import {
-  ID // eslint-disable-line
-} from '../internals.js'
-
-export class AbstractDSEncoder {
-  constructor () {
-    this.restEncoder = encoding.createEncoder()
-  }
-
-  /**
-   * @return {Uint8Array}
-   */
-  toUint8Array () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * Resets the ds value to 0.
-   * The v2 encoder uses this information to reset the initial diff value.
-   */
-  resetDsCurVal () { }
-
-  /**
-   * @param {number} clock
-   */
-  writeDsClock (clock) { }
-
-  /**
-   * @param {number} len
-   */
-  writeDsLen (len) { }
-}
-
-export class AbstractUpdateEncoder extends AbstractDSEncoder {
-  /**
-   * @return {Uint8Array}
-   */
-  toUint8Array () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @param {ID} id
-   */
-  writeLeftID (id) { }
-
-  /**
-   * @param {ID} id
-   */
-  writeRightID (id) { }
-
-  /**
-   * Use writeClient and writeClock instead of writeID if possible.
-   * @param {number} client
-   */
-  writeClient (client) { }
-
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeInfo (info) { }
-
-  /**
-   * @param {string} s
-   */
-  writeString (s) { }
-
-  /**
-   * @param {boolean} isYKey
-   */
-  writeParentInfo (isYKey) { }
-
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeTypeRef (info) { }
-
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @param {number} len
-   */
-  writeLen (len) { }
-
-  /**
-   * @param {any} any
-   */
-  writeAny (any) { }
-
-  /**
-   * @param {Uint8Array} buf
-   */
-  writeBuf (buf) { }
-
-  /**
-   * @param {any} embed
-   */
-  writeJSON (embed) { }
-
-  /**
-   * @param {string} key
-   */
-  writeKey (key) { }
-}
-
-export class DSEncoderV1 {
-  constructor () {
-    this.restEncoder = new encoding.Encoder()
-  }
-
-  toUint8Array () {
-    return encoding.toUint8Array(this.restEncoder)
-  }
-
-  resetDsCurVal () {
-    // nop
-  }
-
-  /**
-   * @param {number} clock
-   */
-  writeDsClock (clock) {
-    encoding.writeVarUint(this.restEncoder, clock)
-  }
-
-  /**
-   * @param {number} len
-   */
-  writeDsLen (len) {
-    encoding.writeVarUint(this.restEncoder, len)
-  }
-}
-
-export class UpdateEncoderV1 extends DSEncoderV1 {
-  /**
-   * @param {ID} id
-   */
-  writeLeftID (id) {
-    encoding.writeVarUint(this.restEncoder, id.client)
-    encoding.writeVarUint(this.restEncoder, id.clock)
-  }
-
-  /**
-   * @param {ID} id
-   */
-  writeRightID (id) {
-    encoding.writeVarUint(this.restEncoder, id.client)
-    encoding.writeVarUint(this.restEncoder, id.clock)
-  }
-
-  /**
-   * Use writeClient and writeClock instead of writeID if possible.
-   * @param {number} client
-   */
-  writeClient (client) {
-    encoding.writeVarUint(this.restEncoder, client)
-  }
-
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeInfo (info) {
-    encoding.writeUint8(this.restEncoder, info)
-  }
-
-  /**
-   * @param {string} s
-   */
-  writeString (s) {
-    encoding.writeVarString(this.restEncoder, s)
-  }
-
-  /**
-   * @param {boolean} isYKey
-   */
-  writeParentInfo (isYKey) {
-    encoding.writeVarUint(this.restEncoder, isYKey ? 1 : 0)
-  }
-
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeTypeRef (info) {
-    encoding.writeVarUint(this.restEncoder, info)
-  }
-
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @param {number} len
-   */
-  writeLen (len) {
-    encoding.writeVarUint(this.restEncoder, len)
-  }
-
-  /**
-   * @param {any} any
-   */
-  writeAny (any) {
-    encoding.writeAny(this.restEncoder, any)
-  }
-
-  /**
-   * @param {Uint8Array} buf
-   */
-  writeBuf (buf) {
-    encoding.writeVarUint8Array(this.restEncoder, buf)
-  }
-
-  /**
-   * @param {any} embed
-   */
-  writeJSON (embed) {
-    encoding.writeVarString(this.restEncoder, JSON.stringify(embed))
-  }
-
-  /**
-   * @param {string} key
-   */
-  writeKey (key) {
-    encoding.writeVarString(this.restEncoder, key)
-  }
-}
-
-export class DSEncoderV2 {
-  constructor () {
-    this.restEncoder = new encoding.Encoder() // encodes all the rest / non-optimized
-    this.dsCurrVal = 0
-  }
-
-  toUint8Array () {
-    return encoding.toUint8Array(this.restEncoder)
-  }
-
-  resetDsCurVal () {
-    this.dsCurrVal = 0
-  }
-
-  /**
-   * @param {number} clock
-   */
-  writeDsClock (clock) {
-    const diff = clock - this.dsCurrVal
-    this.dsCurrVal = clock
-    encoding.writeVarUint(this.restEncoder, diff)
-  }
-
-  /**
-   * @param {number} len
-   */
-  writeDsLen (len) {
-    if (len === 0) {
-      error.unexpectedCase()
-    }
-    encoding.writeVarUint(this.restEncoder, len - 1)
-    this.dsCurrVal += len
-  }
-}
-
-export class UpdateEncoderV2 extends DSEncoderV2 {
-  constructor () {
-    super()
-    /**
-     * @type {Map<string,number>}
-     */
-    this.keyMap = new Map()
-    /**
-     * Refers to the next uniqe key-identifier to me used.
-     * See writeKey method for more information.
-     *
-     * @type {number}
-     */
-    this.keyClock = 0
-    this.keyClockEncoder = new encoding.IntDiffOptRleEncoder()
-    this.clientEncoder = new encoding.UintOptRleEncoder()
-    this.leftClockEncoder = new encoding.IntDiffOptRleEncoder()
-    this.rightClockEncoder = new encoding.IntDiffOptRleEncoder()
-    this.infoEncoder = new encoding.RleEncoder(encoding.writeUint8)
-    this.stringEncoder = new encoding.StringEncoder()
-    this.parentInfoEncoder = new encoding.RleEncoder(encoding.writeUint8)
-    this.typeRefEncoder = new encoding.UintOptRleEncoder()
-    this.lenEncoder = new encoding.UintOptRleEncoder()
-  }
-
-  toUint8Array () {
-    const encoder = encoding.createEncoder()
-    encoding.writeUint8(encoder, 0) // this is a feature flag that we might use in the future
-    encoding.writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, this.clientEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.infoEncoder))
-    encoding.writeVarUint8Array(encoder, this.stringEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.parentInfoEncoder))
-    encoding.writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, this.lenEncoder.toUint8Array())
-    // @note The rest encoder is appended! (note the missing var)
-    encoding.writeUint8Array(encoder, encoding.toUint8Array(this.restEncoder))
-    return encoding.toUint8Array(encoder)
-  }
-
-  /**
-   * @param {ID} id
-   */
-  writeLeftID (id) {
-    this.clientEncoder.write(id.client)
-    this.leftClockEncoder.write(id.clock)
-  }
-
-  /**
-   * @param {ID} id
-   */
-  writeRightID (id) {
-    this.clientEncoder.write(id.client)
-    this.rightClockEncoder.write(id.clock)
-  }
-
-  /**
-   * @param {number} client
-   */
-  writeClient (client) {
-    this.clientEncoder.write(client)
-  }
-
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeInfo (info) {
-    this.infoEncoder.write(info)
-  }
-
-  /**
-   * @param {string} s
-   */
-  writeString (s) {
-    this.stringEncoder.write(s)
-  }
-
-  /**
-   * @param {boolean} isYKey
-   */
-  writeParentInfo (isYKey) {
-    this.parentInfoEncoder.write(isYKey ? 1 : 0)
-  }
-
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeTypeRef (info) {
-    this.typeRefEncoder.write(info)
-  }
-
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @param {number} len
-   */
-  writeLen (len) {
-    this.lenEncoder.write(len)
-  }
-
-  /**
-   * @param {any} any
-   */
-  writeAny (any) {
-    encoding.writeAny(this.restEncoder, any)
-  }
-
-  /**
-   * @param {Uint8Array} buf
-   */
-  writeBuf (buf) {
-    encoding.writeVarUint8Array(this.restEncoder, buf)
-  }
-
-  /**
-   * This is mainly here for legacy purposes.
-   *
-   * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
-   *
-   * @param {any} embed
-   */
-  writeJSON (embed) {
-    encoding.writeAny(this.restEncoder, embed)
-  }
-
-  /**
-   * Property keys are often reused. For example, in y-prosemirror the key `bold` might
-   * occur very often. For a 3d application, the key `position` might occur very often.
-   *
-   * We cache these keys in a Map and refer to them via a unique number.
-   *
-   * @param {string} key
-   */
-  writeKey (key) {
-    const clock = this.keyMap.get(key)
-    if (clock === undefined) {
-      this.keyClockEncoder.write(this.keyClock++)
-      this.stringEncoder.write(key)
-    } else {
-      this.keyClockEncoder.write(this.keyClock++)
-    }
-  }
-}
--- a/src/utils/YEvent.js
+++ b/src/utils/YEvent.js
@@ -1,226 +0,0 @@
-
-import {
-  isDeleted,
-  Item, AbstractType, Transaction, AbstractStruct // eslint-disable-line
-} from '../internals.js'
-
-import * as set from 'lib0/set.js'
-import * as array from 'lib0/array.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
-    /**
-     * @type {Object|null}
-     */
-    this._changes = null
-  }
-
-  /**
-   * 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.
-   *
-   * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
-   *
-   * @param {AbstractStruct} struct
-   * @return {boolean}
-   */
-  deletes (struct) {
-    return isDeleted(this.transaction.deleteSet, struct.id)
-  }
-
-  /**
-   * Check if a struct is added by this event.
-   *
-   * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
-   *
-   * @param {AbstractStruct} struct
-   * @return {boolean}
-   */
-  adds (struct) {
-    return struct.id.clock >= (this.transaction.beforeState.get(struct.id.client) || 0)
-  }
-
-  /**
-   * @return {{added:Set<Item>,deleted:Set<Item>,delta:Array<{insert:Array<any>}|{delete:number}|{retain:number}>}}
-   */
-  get changes () {
-    let changes = this._changes
-    if (changes === null) {
-      const target = this.target
-      const added = set.create()
-      const deleted = set.create()
-      /**
-       * @type {Array<{insert:Array<any>}|{delete:number}|{retain:number}>}
-       */
-      const delta = []
-      /**
-       * @type {Map<string,{ action: 'add' | 'update' | 'delete', oldValue: any}>}
-       */
-      const keys = new Map()
-      changes = {
-        added, deleted, delta, keys
-      }
-      const changed = /** @type Set<string|null> */ (this.transaction.changed.get(target))
-      if (changed.has(null)) {
-        /**
-         * @type {any}
-         */
-        let lastOp = null
-        const packOp = () => {
-          if (lastOp) {
-            delta.push(lastOp)
-          }
-        }
-        for (let item = target._start; item !== null; item = item.right) {
-          if (item.deleted) {
-            if (this.deletes(item) && !this.adds(item)) {
-              if (lastOp === null || lastOp.delete === undefined) {
-                packOp()
-                lastOp = { delete: 0 }
-              }
-              lastOp.delete += item.length
-              deleted.add(item)
-            } // else nop
-          } else {
-            if (this.adds(item)) {
-              if (lastOp === null || lastOp.insert === undefined) {
-                packOp()
-                lastOp = { insert: [] }
-              }
-              lastOp.insert = lastOp.insert.concat(item.content.getContent())
-              added.add(item)
-            } else {
-              if (lastOp === null || lastOp.retain === undefined) {
-                packOp()
-                lastOp = { retain: 0 }
-              }
-              lastOp.retain += item.length
-            }
-          }
-        }
-        if (lastOp !== null && lastOp.retain === undefined) {
-          packOp()
-        }
-      }
-      changed.forEach(key => {
-        if (key !== null) {
-          const item = /** @type {Item} */ (target._map.get(key))
-          /**
-           * @type {'delete' | 'add' | 'update'}
-           */
-          let action
-          let oldValue
-          if (this.adds(item)) {
-            let prev = item.left
-            while (prev !== null && this.adds(prev)) {
-              prev = prev.left
-            }
-            if (this.deletes(item)) {
-              if (prev !== null && this.deletes(prev)) {
-                action = 'delete'
-                oldValue = array.last(prev.content.getContent())
-              } else {
-                return
-              }
-            } else {
-              if (prev !== null && this.deletes(prev)) {
-                action = 'update'
-                oldValue = array.last(prev.content.getContent())
-              } else {
-                action = 'add'
-                oldValue = undefined
-              }
-            }
-          } else {
-            if (this.deletes(item)) {
-              action = 'delete'
-              oldValue = array.last(/** @type {Item} */ item.content.getContent())
-            } else {
-              return // nop
-            }
-          }
-          keys.set(key, { action, oldValue })
-        }
-      })
-      this._changes = changes
-    }
-    return /** @type {any} */ (changes)
-  }
-}
-
-/**
- * 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 = /** @type {AbstractType<any>} */ (child._item.parent)._start
-      while (c !== child._item && c !== null) {
-        if (!c.deleted) {
-          i++
-        }
-        c = c.right
-      }
-      path.unshift(i)
-    }
-    child = /** @type {AbstractType<any>} */ (child._item.parent)
-  }
-  return path
-}
--- a/src/utils/encoding.js
+++ b/src/utils/encoding.js
@@ -1,611 +0,0 @@
-
-/**
- * @module encoding
- */
-/*
- * We use the first five bits in the info flag for determining the type of the struct.
- *
- * 0: GC
- * 1: Item with Deleted content
- * 2: Item with JSON content
- * 3: Item with Binary content
- * 4: Item with String content
- * 5: Item with Embed content (for richtext content)
- * 6: Item with Format content (a formatting marker for richtext content)
- * 7: Item with Type
- */
-
-import {
-  findIndexSS,
-  getState,
-  createID,
-  getStateVector,
-  readAndApplyDeleteSet,
-  writeDeleteSet,
-  createDeleteSetFromStructStore,
-  transact,
-  readItemContent,
-  UpdateDecoderV1,
-  UpdateDecoderV2,
-  UpdateEncoderV1,
-  UpdateEncoderV2,
-  DSDecoderV2,
-  DSEncoderV2,
-  DSDecoderV1,
-  DSEncoderV1,
-  AbstractDSEncoder, AbstractDSDecoder, AbstractUpdateEncoder, AbstractUpdateDecoder, AbstractContent, Doc, Transaction, GC, Item, 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'
-import * as map from 'lib0/map.js'
-
-export let DefaultDSEncoder = DSEncoderV1
-export let DefaultDSDecoder = DSDecoderV1
-export let DefaultUpdateEncoder = UpdateEncoderV1
-export let DefaultUpdateDecoder = UpdateDecoderV1
-
-export const useV1Encoding = () => {
-  DefaultDSEncoder = DSEncoderV1
-  DefaultDSDecoder = DSDecoderV1
-  DefaultUpdateEncoder = UpdateEncoderV1
-  DefaultUpdateDecoder = UpdateDecoderV1
-}
-
-export const useV2Encoding = () => {
-  DefaultDSEncoder = DSEncoderV2
-  DefaultDSDecoder = DSDecoderV2
-  DefaultUpdateEncoder = UpdateEncoderV2
-  DefaultUpdateDecoder = UpdateDecoderV2
-}
-
-/**
- * @param {AbstractUpdateEncoder} encoder
- * @param {Array<GC|Item>} 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.restEncoder, structs.length - startNewStructs)
-  encoder.writeClient(client)
-  encoding.writeVarUint(encoder.restEncoder, clock)
-  const firstStruct = structs[startNewStructs]
-  // write first struct with an offset
-  firstStruct.write(encoder, clock - firstStruct.id.clock)
-  for (let i = startNewStructs + 1; i < structs.length; i++) {
-    structs[i].write(encoder, 0)
-  }
-}
-
-/**
- * @param {AbstractUpdateEncoder} 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.restEncoder, sm.size)
-  // Write items with higher client ids first
-  // This heavily improves the conflict algorithm.
-  Array.from(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
-    // @ts-ignore
-    writeStructs(encoder, store.clients.get(client), client, clock)
-  })
-}
-
-/**
- * @param {AbstractUpdateDecoder} decoder The decoder object to read data from.
- * @param {Map<number,Array<GC|Item>>} clientRefs
- * @param {Doc} doc
- * @return {Map<number,Array<GC|Item>>}
- *
- * @private
- * @function
- */
-export const readClientsStructRefs = (decoder, clientRefs, doc) => {
-  const numOfStateUpdates = decoding.readVarUint(decoder.restDecoder)
-  for (let i = 0; i < numOfStateUpdates; i++) {
-    const numberOfStructs = decoding.readVarUint(decoder.restDecoder)
-    /**
-     * @type {Array<GC|Item>}
-     */
-    const refs = new Array(numberOfStructs)
-    const client = decoder.readClient()
-    let clock = decoding.readVarUint(decoder.restDecoder)
-    // const start = performance.now()
-    clientRefs.set(client, refs)
-    for (let i = 0; i < numberOfStructs; i++) {
-      const info = decoder.readInfo()
-      if ((binary.BITS5 & info) !== 0) {
-        /**
-         * The optimized implementation doesn't use any variables because inlining variables is faster.
-         * Below a non-optimized version is shown that implements the basic algorithm with
-         * a few comments
-         */
-        const cantCopyParentInfo = (info & (binary.BIT7 | binary.BIT8)) === 0
-        // 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}
-        const struct = new Item(
-          createID(client, clock),
-          null, // leftd
-          (info & binary.BIT8) === binary.BIT8 ? decoder.readLeftID() : null, // origin
-          null, // right
-          (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null, // right origin
-          cantCopyParentInfo ? (decoder.readParentInfo() ? doc.get(decoder.readString()) : decoder.readLeftID()) : null, // parent
-          cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readString() : null, // parentSub
-          readItemContent(decoder, info) // item content
-        )
-        /* A non-optimized implementation of the above algorithm:
-
-        // The item that was originally to the left of this item.
-        const origin = (info & binary.BIT8) === binary.BIT8 ? decoder.readLeftID() : null
-        // The item that was originally to the right of this item.
-        const rightOrigin = (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null
-        const cantCopyParentInfo = (info & (binary.BIT7 | binary.BIT8)) === 0
-        const hasParentYKey = cantCopyParentInfo ? decoder.readParentInfo() : 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}
-        const parentYKey = cantCopyParentInfo && hasParentYKey ? decoder.readString() : null
-
-        const struct = new Item(
-          createID(client, clock),
-          null, // leftd
-          origin, // origin
-          null, // right
-          rightOrigin, // right origin
-          cantCopyParentInfo && !hasParentYKey ? decoder.readLeftID() : (parentYKey !== null ? doc.get(parentYKey) : null), // parent
-          cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readString() : null, // parentSub
-          readItemContent(decoder, info) // item content
-        )
-        */
-        refs[i] = struct
-        clock += struct.length
-      } else {
-        const len = decoder.readLen()
-        refs[i] = new GC(createID(client, clock), len)
-        clock += len
-      }
-    }
-    // console.log('time to read: ', performance.now() - start) // @todo remove
-  }
-  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 // @todo don't forget to append stackhead at the end
-  const clientsStructRefs = store.pendingClientsStructRefs
-  // sort them so that we take the higher id first, in case of conflicts the lower id will probably not conflict with the id from the higher user.
-  const clientsStructRefsIds = Array.from(clientsStructRefs.keys()).sort((a, b) => a - b)
-  if (clientsStructRefsIds.length === 0) {
-    return
-  }
-  const getNextStructTarget = () => {
-    let nextStructsTarget = /** @type {{i:number,refs:Array<GC|Item>}} */ (clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1]))
-    while (nextStructsTarget.refs.length === nextStructsTarget.i) {
-      clientsStructRefsIds.pop()
-      if (clientsStructRefsIds.length > 0) {
-        nextStructsTarget = /** @type {{i:number,refs:Array<GC|Item>}} */ (clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1]))
-      } else {
-        store.pendingClientsStructRefs.clear()
-        return null
-      }
-    }
-    return nextStructsTarget
-  }
-  let curStructsTarget = getNextStructTarget()
-  if (curStructsTarget === null && stack.length === 0) {
-    return
-  }
-  /**
-   * @type {GC|Item}
-   */
-  let stackHead = stack.length > 0
-    ? /** @type {GC|Item} */ (stack.pop())
-    : /** @type {any} */ (curStructsTarget).refs[/** @type {any} */ (curStructsTarget).i++]
-  // caching the state because it is used very often
-  const state = new Map()
-  // iterate over all struct readers until we are done
-  while (true) {
-    const localClock = map.setIfUndefined(state, stackHead.id.client, () => getState(store, stackHead.id.client))
-    const offset = stackHead.id.clock < localClock ? localClock - stackHead.id.clock : 0
-    if (stackHead.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
-      /**
-       * @type {{ refs: Array<GC|Item>, i: number }}
-       */
-      const structRefs = clientsStructRefs.get(stackHead.id.client) || { refs: [], i: 0 }
-      if (structRefs.refs.length !== structRefs.i) {
-        const r = structRefs.refs[structRefs.i]
-        if (r.id.clock < stackHead.id.clock) {
-          // put ref with smaller clock on stack instead and continue
-          structRefs.refs[structRefs.i] = stackHead
-          stackHead = 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
-      stack.push(stackHead)
-      return
-    }
-    const missing = stackHead.getMissing(transaction, store)
-    if (missing === null) {
-      if (offset === 0 || offset < stackHead.length) {
-        stackHead.integrate(transaction, offset)
-        state.set(stackHead.id.client, stackHead.id.clock + stackHead.length)
-      }
-      // iterate to next stackHead
-      if (stack.length > 0) {
-        stackHead = /** @type {GC|Item} */ (stack.pop())
-      } else if (curStructsTarget !== null && curStructsTarget.i < curStructsTarget.refs.length) {
-        stackHead = /** @type {GC|Item} */ (curStructsTarget.refs[curStructsTarget.i++])
-      } else {
-        curStructsTarget = getNextStructTarget()
-        if (curStructsTarget === null) {
-          // we are done!
-          break
-        } else {
-          stackHead = /** @type {GC|Item} */ (curStructsTarget.refs[curStructsTarget.i++])
-        }
-      }
-    } else {
-      // get the struct reader that has the missing struct
-      /**
-       * @type {{ refs: Array<GC|Item>, i: number }}
-       */
-      const structRefs = clientsStructRefs.get(missing) || { refs: [], i: 0 }
-      if (structRefs.refs.length === structRefs.i) {
-        // This update message causally depends on another update message.
-        stack.push(stackHead)
-        return
-      }
-      stack.push(stackHead)
-      stackHead = structRefs.refs[structRefs.i++]
-    }
-  }
-  store.pendingClientsStructRefs.clear()
-}
-
-/**
- * @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++) {
-    readAndApplyDeleteSet(pendingReaders[i], transaction, store)
-  }
-}
-
-/**
- * @param {AbstractUpdateEncoder} 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<GC|Item>>} clientsStructsRefs
- *
- * @private
- * @function
- */
-const mergeReadStructsIntoPendingReads = (store, clientsStructsRefs) => {
-  const pendingClientsStructRefs = store.pendingClientsStructRefs
-  clientsStructsRefs.forEach((structRefs, client) => {
-    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)
-    }
-  })
-}
-
-/**
- * @param {Map<number,{refs:Array<GC|Item>,i:number}>} pendingClientsStructRefs
- */
-const cleanupPendingStructs = pendingClientsStructRefs => {
-  // cleanup pendingClientsStructs if not fully finished
-  pendingClientsStructRefs.forEach((refs, client) => {
-    if (refs.i === refs.refs.length) {
-      pendingClientsStructRefs.delete(client)
-    } else {
-      refs.refs.splice(0, refs.i)
-      refs.i = 0
-    }
-  })
-}
-
-/**
- * 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 {AbstractUpdateDecoder} decoder The decoder object to read data from.
- * @param {Transaction} transaction
- * @param {StructStore} store
- *
- * @private
- * @function
- */
-export const readStructs = (decoder, transaction, store) => {
-  const clientsStructRefs = new Map()
-  // let start = performance.now()
-  readClientsStructRefs(decoder, clientsStructRefs, transaction.doc)
-  // console.log('time to read structs: ', performance.now() - start) // @todo remove
-  // start = performance.now()
-  mergeReadStructsIntoPendingReads(store, clientsStructRefs)
-  // console.log('time to merge: ', performance.now() - start) // @todo remove
-  // start = performance.now()
-  resumeStructIntegration(transaction, store)
-  // console.log('time to integrate: ', performance.now() - start) // @todo remove
-  // start = performance.now()
-  cleanupPendingStructs(store.pendingClientsStructRefs)
-  // console.log('time to cleanup: ', performance.now() - start) // @todo remove
-  // start = performance.now()
-  tryResumePendingDeleteReaders(transaction, store)
-  // console.log('time to resume delete readers: ', performance.now() - start) // @todo remove
-  // start = performance.now()
-}
-
-/**
- * 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))`
- * @param {AbstractUpdateDecoder} [structDecoder]
- *
- * @function
- */
-export const readUpdateV2 = (decoder, ydoc, transactionOrigin, structDecoder = new UpdateDecoderV2(decoder)) =>
-  transact(ydoc, transaction => {
-    readStructs(structDecoder, transaction, ydoc.store)
-    readAndApplyDeleteSet(structDecoder, transaction, ydoc.store)
-  }, transactionOrigin, false)
-
-/**
- * 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) => readUpdateV2(decoder, ydoc, transactionOrigin, new DefaultUpdateDecoder(decoder))
-
-/**
- * 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))`
- * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]
- *
- * @function
- */
-export const applyUpdateV2 = (ydoc, update, transactionOrigin, YDecoder = UpdateDecoderV2) => {
-  const decoder = decoding.createDecoder(update)
-  readUpdateV2(decoder, ydoc, transactionOrigin, new YDecoder(decoder))
-}
-
-/**
- * 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) => applyUpdateV2(ydoc, update, transactionOrigin, DefaultUpdateDecoder)
-
-/**
- * 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 {AbstractUpdateEncoder} 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
- * @param {AbstractUpdateEncoder} [encoder]
- * @return {Uint8Array}
- *
- * @function
- */
-export const encodeStateAsUpdateV2 = (doc, encodedTargetStateVector, encoder = new UpdateEncoderV2()) => {
-  const targetStateVector = encodedTargetStateVector == null ? new Map() : decodeStateVector(encodedTargetStateVector)
-  writeStateAsUpdate(encoder, doc, targetStateVector)
-  return encoder.toUint8Array()
-}
-
-/**
- * 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) => encodeStateAsUpdateV2(doc, encodedTargetStateVector, new DefaultUpdateEncoder())
-
-/**
- * Read state vector from Decoder and return as Map
- *
- * @param {AbstractDSDecoder} 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.restDecoder)
-  for (let i = 0; i < ssLength; i++) {
-    const client = decoding.readVarUint(decoder.restDecoder)
-    const clock = decoding.readVarUint(decoder.restDecoder)
-    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 decodeStateVectorV2 = decodedState => readStateVector(new DSDecoderV2(decoding.createDecoder(decodedState)))
-
-/**
- * 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(new DefaultDSDecoder(decoding.createDecoder(decodedState)))
-
-/**
- * @param {AbstractDSEncoder} encoder
- * @param {Map<number,number>} sv
- * @function
- */
-export const writeStateVector = (encoder, sv) => {
-  encoding.writeVarUint(encoder.restEncoder, sv.size)
-  sv.forEach((clock, client) => {
-    encoding.writeVarUint(encoder.restEncoder, client) // @todo use a special client decoder that is based on mapping
-    encoding.writeVarUint(encoder.restEncoder, clock)
-  })
-  return encoder
-}
-
-/**
- * @param {AbstractDSEncoder} encoder
- * @param {Doc} doc
- *
- * @function
- */
-export const writeDocumentStateVector = (encoder, doc) => writeStateVector(encoder, getStateVector(doc.store))
-
-/**
- * Encode State as Uint8Array.
- *
- * @param {Doc} doc
- * @param {AbstractDSEncoder} [encoder]
- * @return {Uint8Array}
- *
- * @function
- */
-export const encodeStateVectorV2 = (doc, encoder = new DSEncoderV2()) => {
-  writeDocumentStateVector(encoder, doc)
-  return encoder.toUint8Array()
-}
-
-/**
- * Encode State as Uint8Array.
- *
- * @param {Doc} doc
- * @return {Uint8Array}
- *
- * @function
- */
-export const encodeStateVector = doc => encodeStateVectorV2(doc, new DefaultDSEncoder())
--- a/src/utils/isParentOf.js
+++ b/src/utils/isParentOf.js
@@ -1,22 +0,0 @@
-
-import { AbstractType, Item } from '../internals.js' // eslint-disable-line
-
-/**
- * Check if `parent` is a parent of `child`.
- *
- * @param {AbstractType<any>} parent
- * @param {Item|null} child
- * @return {Boolean} Whether `parent` is a parent of `child`.
- *
- * @private
- * @function
- */
-export const isParentOf = (parent, child) => {
-  while (child !== null) {
-    if (child.parent === parent) {
-      return true
-    }
-    child = /** @type {AbstractType<any>} */ (child.parent)._item
-  }
-  return false
-}
--- a/src/utils/logging.js
+++ b/src/utils/logging.js
@@ -1,22 +0,0 @@
-
-import {
-  AbstractType // eslint-disable-line
-} from '../internals.js'
-
-/**
- * Convenient helper to log type information.
- *
- * Do not use in productive systems as the output can be immense!
- *
- * @param {AbstractType<any>} type
- */
-export const logType = type => {
-  const res = []
-  let n = type._start
-  while (n) {
-    res.push(n)
-    n = n.right
-  }
-  console.log('Children: ', res)
-  console.log('Children content: ', res.filter(m => !m.deleted).map(m => m.content))
-}
--- a/src/y-memory.js
+++ b/src/y-memory.js
@@ -0,0 +1,67 @@
+import extendRBTree from './RedBlackTree'
+
+export default function extend (Y) {
+  extendRBTree(Y)
+
+  class Transaction extends Y.Transaction {
+    constructor (store) {
+      super(store)
+      this.store = store
+      this.ss = store.ss
+      this.os = store.os
+      this.ds = store.ds
+    }
+  }
+  var Store = Y.utils.RBTree
+  var BufferedStore = Y.utils.createSmallLookupBuffer(Store)
+
+  class Database extends Y.AbstractDatabase {
+    constructor (y, opts) {
+      super(y, opts)
+      this.os = new BufferedStore()
+      this.ds = new Store()
+      this.ss = new BufferedStore()
+    }
+    logTable () {
+      var self = this
+      self.requestTransaction(function () {
+        console.log('User: ', this.store.y.connector.userId, "==============================") // eslint-disable-line
+        console.log("State Set (SS):", this.getStateSet()) // eslint-disable-line
+        console.log("Operation Store (OS):") // eslint-disable-line
+        this.os.logTable() // eslint-disable-line
+        console.log("Deletion Store (DS):") //eslint-disable-line
+        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) {
+      const t = new Transaction(this)
+      try {
+        while (makeGen != null) {
+          makeGen.call(t)
+          makeGen = this.getNextRequest()
+        }
+      } catch (e) {
+        this.y.emit('error', e)
+      }
+    }
+    destroy () {
+      super.destroy()
+      delete this.os
+      delete this.ss
+      delete this.ds
+    }
+  }
+  Y.memory = Database
+}
--- a/src/y.js
+++ b/src/y.js
@@ -0,0 +1,258 @@
+import extendConnector from './Connector.js'
+import extendPersistence from './Persistence.js'
+import extendDatabase from './Database.js'
+import extendTransaction from './Transaction.js'
+import extendStruct from './Struct.js'
+import extendUtils from './Utils.js'
+import extendMemory from './y-memory.js'
+import debug from 'debug'
+import { formatYjsMessage, formatYjsMessageType } from './MessageHandler.js'
+
+extendConnector(Y)
+extendPersistence(Y)
+extendDatabase(Y)
+extendTransaction(Y)
+extendStruct(Y)
+extendUtils(Y)
+extendMemory(Y)
+
+Y.debug = debug
+debug.formatters.Y = formatYjsMessage
+debug.formatters.y = formatYjsMessageType
+
+var requiringModules = {}
+
+Y.requiringModules = requiringModules
+
+Y.extend = function (name, value) {
+  if (arguments.length === 2 && typeof name === 'string') {
+    if (value instanceof Y.utils.CustomTypeDefinition) {
+      Y[name] = value.parseArguments
+    } else {
+      Y[name] = value
+    }
+    if (requiringModules[name] != null) {
+      requiringModules[name].resolve()
+      delete requiringModules[name]
+    }
+  } else {
+    for (var i = 0; i < arguments.length; i++) {
+      var f = arguments[i]
+      if (typeof f === 'function') {
+        f(Y)
+      } else {
+        throw new Error('Expected function!')
+      }
+    }
+  }
+}
+
+Y.requestModules = requestModules
+function requestModules (modules) {
+  var sourceDir
+  if (Y.sourceDir === null) {
+    sourceDir = null
+  } else {
+    sourceDir = Y.sourceDir || '/bower_components'
+  }
+  // determine if this module was compiled for es5 or es6 (y.js vs. y.es6)
+  // if Insert.execute is a Function, then it isnt a generator..
+  // then load the es5(.js) files..
+  var extention = typeof regeneratorRuntime !== 'undefined' ? '.js' : '.es6'
+  var promises = []
+  for (var i = 0; i < modules.length; i++) {
+    var module = modules[i].split('(')[0]
+    var modulename = 'y-' + module.toLowerCase()
+    if (Y[module] == null) {
+      if (requiringModules[module] == null) {
+        // module does not exist
+        if (typeof window !== 'undefined' && window.Y !== 'undefined') {
+          if (sourceDir != null) {
+            var imported = document.createElement('script')
+            imported.src = sourceDir + '/' + modulename + '/' + modulename + extention
+            document.head.appendChild(imported)
+          }
+          let requireModule = {}
+          requiringModules[module] = requireModule
+          requireModule.promise = new Promise(function (resolve) {
+            requireModule.resolve = resolve
+          })
+          promises.push(requireModule.promise)
+        } else {
+          console.info('YJS: Please do not depend on automatic requiring of modules anymore! Extend modules as follows `require(\'y-modulename\')(Y)`')
+          require(modulename)(Y)
+        }
+      } else {
+        promises.push(requiringModules[modules[i]].promise)
+      }
+    }
+  }
+  return Promise.all(promises)
+}
+
+/* ::
+type MemoryOptions = {
+  name: 'memory'
+}
+type IndexedDBOptions = {
+  name: 'indexeddb',
+  namespace: string
+}
+type DbOptions = MemoryOptions | IndexedDBOptions
+
+type WebRTCOptions = {
+  name: 'webrtc',
+  room: string
+}
+type WebsocketsClientOptions = {
+  name: 'websockets-client',
+  room: string
+}
+type ConnectionOptions = WebRTCOptions | WebsocketsClientOptions
+
+type YOptions = {
+  connector: ConnectionOptions,
+  db: DbOptions,
+  types: Array<TypeName>,
+  sourceDir: string,
+  share: {[key: string]: TypeName}
+}
+*/
+
+export default function Y (opts/* :YOptions */) /* :Promise<YConfig> */ {
+  if (opts.hasOwnProperty('sourceDir')) {
+    Y.sourceDir = opts.sourceDir
+  }
+  opts.types = opts.types != null ? opts.types : []
+  var modules = [opts.db.name, opts.connector.name].concat(opts.types)
+  for (var name in opts.share) {
+    modules.push(opts.share[name])
+  }
+  return new Promise(function (resolve, reject) {
+    if (opts == null) reject(new Error('An options object is expected!'))
+    else if (opts.connector == null) reject(new Error('You must specify a connector! (missing connector property)'))
+    else if (opts.connector.name == null) reject(new Error('You must specify connector name! (missing connector.name property)'))
+    else if (opts.db == null) reject(new Error('You must specify a database! (missing db property)'))
+    else if (opts.connector.name == null) reject(new Error('You must specify db name! (missing db.name property)'))
+    else {
+      opts = Y.utils.copyObject(opts)
+      opts.connector = Y.utils.copyObject(opts.connector)
+      opts.db = Y.utils.copyObject(opts.db)
+      opts.share = Y.utils.copyObject(opts.share)
+      Y.requestModules(modules).then(function () {
+        var yconfig = new YConfig(opts)
+        let resolved = false
+        if (opts.timeout != null && opts.timeout >= 0) {
+          setTimeout(function () {
+            if (!resolved) {
+              reject(new Error('Yjs init timeout'))
+              yconfig.destroy()
+            }
+          }, opts.timeout)
+        }
+        if (yconfig.persistence != null) {
+          yconfig.persistence.retrieveContent()
+        }
+        yconfig.db.whenUserIdSet(function () {
+          yconfig.init(function () {
+            resolved = true
+            resolve(yconfig)
+          }, reject)
+        })
+      }).catch(reject)
+    }
+  })
+}
+
+class YConfig extends Y.utils.NamedEventHandler {
+  /* ::
+  db: Y.AbstractDatabase;
+  connector: Y.AbstractConnector;
+  share: {[key: string]: any};
+  options: Object;
+  */
+  constructor (opts, callback) {
+    super()
+    this.options = opts
+    this.db = new Y[opts.db.name](this, opts.db)
+    this.connector = new Y[opts.connector.name](this, opts.connector)
+    if (opts.persistence != null) {
+      this.persistence = new Y[opts.persistence.name](this, opts.persistence)
+    } else {
+      this.persistence = null
+    }
+    this.connected = true
+  }
+  init (callback) {
+    var opts = this.options
+    var share = {}
+    this.share = share
+    this.db.requestTransaction(function requestTransaction () {
+      // create shared object
+      for (var propertyname in opts.share) {
+        var typeConstructor = opts.share[propertyname].split('(')
+        let typeArgs = ''
+        if (typeConstructor.length === 2) {
+          typeArgs = typeConstructor[1].split(')')[0] || ''
+        }
+        var typeName = typeConstructor.splice(0, 1)
+        var type = Y[typeName]
+        var typedef = type.typeDefinition
+        var id = [0xFFFFFF, typedef.struct + '_' + typeName + '_' + propertyname + '_' + typeArgs]
+        let args = Y.utils.parseTypeDefinition(type, typeArgs)
+        share[propertyname] = this.store.initType.call(this, id, args)
+      }
+    })
+    this.db.whenTransactionsFinished()
+      .then(callback)
+  }
+  isConnected () {
+    return this.connector.isSynced
+  }
+  disconnect () {
+    if (this.connected) {
+      this.connected = false
+      return this.connector.disconnect()
+    } else {
+      return Promise.resolve()
+    }
+  }
+  reconnect () {
+    if (!this.connected) {
+      this.connected = true
+      return this.connector.reconnect()
+    } else {
+      return Promise.resolve()
+    }
+  }
+  destroy () {
+    var self = this
+    return this.close().then(function () {
+      if (self.db.deleteDB != null) {
+        return self.db.deleteDB()
+      } else {
+        return Promise.resolve()
+      }
+    }).then(() => {
+      // remove existing event listener
+      super.destroy()
+    })
+  }
+  close () {
+    var self = this
+    this.share = null
+    if (this.connector.destroy != null) {
+      this.connector.destroy()
+    } else {
+      this.connector.disconnect()
+    }
+    return this.db.whenTransactionsFinished().then(function () {
+      self.db.destroyTypes()
+      // make sure to wait for all transactions before destroying the db
+      self.db.requestTransaction(function () {
+        self.db.destroy()
+      })
+      return self.db.whenTransactionsFinished()
+    })
+  }
+}
--- a/test.html
+++ b/test.html
@@ -1,9 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Testing Yjs</title>
-</head>
-<body>
-  <script type="module" src="./dist/tests.js"></script>
-</body>
-</html>
--- a/test/encode-decode.js
+++ b/test/encode-decode.js
@@ -0,0 +1,180 @@
+import { test } from 'cutest'
+import Chance from 'chance'
+import Y from '../src/y.js'
+import { BinaryEncoder, BinaryDecoder } from '../src/Encoding.js'
+
+function testEncoding (t, write, read, val) {
+  let encoder = new BinaryEncoder()
+  write(encoder, val)
+  let reader = new BinaryDecoder(encoder.createBuffer())
+  let result = read(reader)
+  t.log(`string encode: ${JSON.stringify(val).length} bytes / binary encode: ${encoder.data.length} bytes`)
+  t.compare(val, result, 'Compare results')
+}
+
+const writeVarUint = (encoder, val) => encoder.writeVarUint(val)
+const readVarUint = decoder => decoder.readVarUint()
+
+test('varUint 1 byte', async function varUint1 (t) {
+  testEncoding(t, writeVarUint, readVarUint, 42)
+})
+
+test('varUint 2 bytes', async function varUint2 (t) {
+  testEncoding(t, writeVarUint, readVarUint, 1 << 9 | 3)
+  testEncoding(t, writeVarUint, readVarUint, 1 << 9 | 3)
+})
+test('varUint 3 bytes', async function varUint3 (t) {
+  testEncoding(t, writeVarUint, readVarUint, 1 << 17 | 1 << 9 | 3)
+})
+
+test('varUint 4 bytes', async function varUint4 (t) {
+  testEncoding(t, writeVarUint, readVarUint, 1 << 25 | 1 << 17 | 1 << 9 | 3)
+})
+
+test('varUint of 2839012934', async function varUint2839012934 (t) {
+  testEncoding(t, writeVarUint, readVarUint, 2839012934)
+})
+
+test('varUint random', async function varUintRandom (t) {
+  const chance = new Chance(t.getSeed() * Math.pow(Number.MAX_SAFE_INTEGER))
+  testEncoding(t, writeVarUint, readVarUint, chance.integer({min: 0, max: (1 << 28) - 1}))
+})
+
+test('varUint random user id', async function varUintRandomUserId (t) {
+  t.getSeed() // enforces that this test is repeated
+  testEncoding(t, writeVarUint, readVarUint, Y.utils.generateUserId())
+})
+
+const writeVarString = (encoder, val) => encoder.writeVarString(val)
+const readVarString = decoder => decoder.readVarString()
+
+test('varString', async function varString (t) {
+  testEncoding(t, writeVarString, readVarString, 'hello')
+  testEncoding(t, writeVarString, readVarString, 'test!')
+  testEncoding(t, writeVarString, readVarString, '☺☺☺')
+  testEncoding(t, writeVarString, readVarString, '1234')
+})
+
+test('varString random', async function varStringRandom (t) {
+  const chance = new Chance(t.getSeed() * 1000000000)
+  testEncoding(t, writeVarString, readVarString, chance.string())
+})
+
+const writeDelete = Y.Struct.Delete.binaryEncode
+const readDelete = Y.Struct.Delete.binaryDecode
+
+test('encode/decode Delete operation', async function binDelete (t) {
+  let op = {
+    target: [10, 3000],
+    length: 40000,
+    struct: 'Delete'
+  }
+  testEncoding(t, writeDelete, readDelete, op)
+})
+
+const writeInsert = Y.Struct.Insert.binaryEncode
+const readInsert = Y.Struct.Insert.binaryDecode
+
+test('encode/decode Insert operations', async function binInsert (t) {
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: [5, 6],
+    left: [3, 4],
+    origin: [7, 8],
+    parent: [9, 10],
+    struct: 'Insert',
+    content: ['a']
+  })
+
+  t.log('left === origin')
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: [5, 6],
+    left: [3, 4],
+    origin: [3, 4],
+    parent: [9, 10],
+    struct: 'Insert',
+    content: ['a']
+  })
+
+  t.log('parentsub')
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: [5, 6],
+    left: [3, 4],
+    origin: [3, 4],
+    parent: [9, 10],
+    parentSub: 'sub',
+    struct: 'Insert',
+    content: ['a']
+  })
+
+  t.log('opContent')
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: [5, 6],
+    left: [3, 4],
+    origin: [3, 4],
+    parent: [9, 10],
+    struct: 'Insert',
+    opContent: [1000, 10000]
+  })
+
+  t.log('mixed content')
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: [5, 6],
+    left: [3, 4],
+    origin: [3, 4],
+    parent: [9, 10],
+    struct: 'Insert',
+    content: ['a', 1]
+  })
+
+  t.log('origin is null')
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: [5, 6],
+    left: [3, 4],
+    origin: null,
+    parent: [9, 10],
+    struct: 'Insert',
+    content: ['a']
+  })
+
+  t.log('left = origin = right = null')
+  testEncoding(t, writeInsert, readInsert, {
+    id: [1, 2],
+    right: null,
+    left: null,
+    origin: null,
+    parent: [9, 10],
+    struct: 'Insert',
+    content: ['a']
+  })
+})
+
+const writeList = Y.Struct.List.binaryEncode
+const readList = Y.Struct.List.binaryDecode
+
+test('encode/decode List operations', async function binList (t) {
+  testEncoding(t, writeList, readList, {
+    struct: 'List',
+    id: [100, 33],
+    type: 'Array',
+    start: null,
+    end: null
+  })
+})
+
+const writeMap = Y.Struct.Map.binaryEncode
+const readMap = Y.Struct.Map.binaryDecode
+
+test('encode/decode Map operations', async function binMap (t) {
+  testEncoding(t, writeMap, readMap, {
+    struct: 'Map',
+    id: [100, 33],
+    type: 'Map',
+    map: {}
+  })
+})
--- a/test/red-black-tree.js
+++ b/test/red-black-tree.js
@@ -0,0 +1,217 @@
+import Y from '../src/y.js'
+import Chance from 'chance'
+import { test, proxyConsole } from 'cutest'
+
+proxyConsole()
+
+var numberOfRBTreeTests = 10000
+
+function checkRedNodesDoNotHaveBlackChildren (t, tree) {
+  let correct = true
+  function traverse (n) {
+    if (n == null) {
+      return
+    }
+    if (n.isRed()) {
+      if (n.left != null) {
+        correct = correct && !n.left.isRed()
+      }
+      if (n.right != null) {
+        correct = correct && !n.right.isRed()
+      }
+    }
+    traverse(n.left)
+    traverse(n.right)
+  }
+  traverse(tree.root)
+  t.assert(correct, 'Red nodes do not have black children')
+}
+
+function checkBlackHeightOfSubTreesAreEqual (t, tree) {
+  let correct = true
+  function traverse (n) {
+    if (n == null) {
+      return 0
+    }
+    var sub1 = traverse(n.left)
+    var sub2 = traverse(n.right)
+    if (sub1 !== sub2) {
+      correct = false
+    }
+    if (n.isRed()) {
+      return sub1
+    } else {
+      return sub1 + 1
+    }
+  }
+  traverse(tree.root)
+  t.assert(correct, 'Black-height of sub-trees are equal')
+}
+
+function checkRootNodeIsBlack (t, tree) {
+  t.assert(tree.root == null || tree.root.isBlack(), 'root node is black')
+}
+
+test('RedBlack Tree', async function redBlackTree (t) {
+  let memory = new Y.memory(null, { // eslint-disable-line
+    name: 'Memory',
+    gcTimeout: -1
+  })
+  let tree = memory.os
+  memory.requestTransaction(function () {
+    tree.put({id: [8433]})
+    tree.put({id: [12844]})
+    tree.put({id: [1795]})
+    tree.put({id: [30302]})
+    tree.put({id: [64287]})
+    tree.delete([8433])
+    tree.put({id: [28996]})
+    tree.delete([64287])
+    tree.put({id: [22721]})
+  })
+  await memory.whenTransactionsFinished()
+  checkRootNodeIsBlack(t, tree)
+  checkBlackHeightOfSubTreesAreEqual(t, tree)
+  checkRedNodesDoNotHaveBlackChildren(t, tree)
+})
+
+test(`random tests (${numberOfRBTreeTests})`, async function random (t) {
+  let chance = new Chance(t.getSeed() * 1000000000)
+  let memory = new Y.memory(null, { // eslint-disable-line
+    name: 'Memory',
+    gcTimeout: -1
+  })
+  let tree = memory.os
+  let elements = []
+  memory.requestTransaction(function () {
+    for (var i = 0; i < numberOfRBTreeTests; i++) {
+      if (chance.bool({likelihood: 80})) {
+        // 80% chance to insert an element
+        let obj = [chance.integer({min: 0, max: numberOfRBTreeTests})]
+        let nodeExists = tree.find(obj)
+        if (!nodeExists) {
+          if (elements.some(e => e[0] === obj[0])) {
+            t.assert(false, 'tree and elements contain different results')
+          }
+          elements.push(obj)
+          tree.put({id: obj})
+        }
+      } else if (elements.length > 0) {
+        // ~20% chance to delete an element
+        var elem = chance.pickone(elements)
+        elements = elements.filter(function (e) {
+          return !Y.utils.compareIds(e, elem)
+        })
+        tree.delete(elem)
+      }
+    }
+  })
+  await memory.whenTransactionsFinished()
+  checkRootNodeIsBlack(t, tree)
+  checkBlackHeightOfSubTreesAreEqual(t, tree)
+  checkRedNodesDoNotHaveBlackChildren(t, tree)
+  memory.requestTransaction(function () {
+    let allNodesExist = true
+    for (let id of elements) {
+      let node = tree.find(id)
+      if (!Y.utils.compareIds(node.id, id)) {
+        allNodesExist = false
+      }
+    }
+    t.assert(allNodesExist, 'All inserted nodes exist')
+  })
+  memory.requestTransaction(function () {
+    let findAllNodesWithLowerBoundSerach = true
+    for (let id of elements) {
+      let node = tree.findWithLowerBound(id)
+      if (!Y.utils.compareIds(node.id, id)) {
+        findAllNodesWithLowerBoundSerach = false
+      }
+    }
+    t.assert(
+      findAllNodesWithLowerBoundSerach,
+      'Find every object with lower bound search'
+    )
+  })
+
+  memory.requestTransaction(function () {
+    let lowerBound = chance.pickone(elements)
+    let expectedResults = elements.filter((e, pos) =>
+      (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) &&
+      elements.indexOf(e) === pos
+    ).length
+    let actualResults = 0
+    tree.iterate(this, lowerBound, null, function (val) {
+      if (val == null) {
+        t.assert(false, 'val is undefined!')
+      }
+      actualResults++
+    })
+    t.assert(
+      expectedResults === actualResults,
+      'Iterating over a tree with lower bound yields the right amount of results'
+    )
+  })
+
+  memory.requestTransaction(function () {
+    let expectedResults = elements.filter((e, pos) =>
+      elements.indexOf(e) === pos
+    ).length
+    let actualResults = 0
+    tree.iterate(this, null, null, function (val) {
+      if (val == null) {
+        t.assert(false, 'val is undefined!')
+      }
+      actualResults++
+    })
+    t.assert(
+      expectedResults === actualResults,
+      'iterating over a tree without bounds yields the right amount of results'
+    )
+  })
+
+  memory.requestTransaction(function () {
+    let upperBound = chance.pickone(elements)
+    let expectedResults = elements.filter((e, pos) =>
+      (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) &&
+      elements.indexOf(e) === pos
+    ).length
+    let actualResults = 0
+    tree.iterate(this, null, upperBound, function (val) {
+      if (val == null) {
+        t.assert(false, 'val is undefined!')
+      }
+      actualResults++
+    })
+    t.assert(
+      expectedResults === actualResults,
+      'iterating over a tree with upper bound yields the right amount of results'
+    )
+  })
+
+  memory.requestTransaction(function () {
+    let upperBound = chance.pickone(elements)
+    let lowerBound = chance.pickone(elements)
+    if (Y.utils.smaller(upperBound, lowerBound)) {
+      [lowerBound, upperBound] = [upperBound, lowerBound]
+    }
+    let expectedResults = elements.filter((e, pos) =>
+      (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
+    let actualResults = 0
+    tree.iterate(this, lowerBound, upperBound, function (val) {
+      if (val == null) {
+        t.assert(false, 'val is undefined!')
+      }
+      actualResults++
+    })
+    t.assert(
+      expectedResults === actualResults,
+      'iterating over a tree with upper bound yields the right amount of results'
+    )
+  })
+
+  await memory.whenTransactionsFinished()
+})
--- a/test/y-array.tests.js
+++ b/test/y-array.tests.js
@@ -0,0 +1,374 @@
+import { wait, initArrays, compareUsers, Y, flushAll, garbageCollectUsers, applyRandomTests } from '../tests-lib/helper.js'
+import { test, proxyConsole } from 'cutest'
+
+proxyConsole()
+
+test('basic spec', async function array0 (t) {
+  let { users, array0 } = await initArrays(t, { users: 2 })
+
+  array0.delete(0, 0)
+  t.assert(true, 'Does not throw when deleting zero elements with position 0')
+
+  let throwInvalidPosition = false
+  try {
+    array0.delete(1, 0)
+  } catch (e) {
+    throwInvalidPosition = true
+  }
+  t.assert(throwInvalidPosition, 'Throws when deleting zero elements with an invalid position')
+
+  array0.insert(0, ['A'])
+  array0.delete(1, 0)
+  t.assert(true, 'Does not throw when deleting zero elements with valid position 1')
+
+  await compareUsers(t, users)
+})
+
+test('insert three elements, try re-get property', async function array1 (t) {
+  var { users, array0, array1 } = await initArrays(t, { users: 2 })
+  array0.insert(0, [1, 2, 3])
+  t.compare(array0.toArray(), [1, 2, 3], '.toArray() works')
+  await flushAll(t, users)
+  t.compare(array1.toArray(), [1, 2, 3], '.toArray() works after sync')
+  await compareUsers(t, users)
+})
+
+test('concurrent insert (handle three conflicts)', async function array2 (t) {
+  var { users, array0, array1, array2 } = await initArrays(t, { users: 3 })
+  array0.insert(0, [0])
+  array1.insert(0, [1])
+  array2.insert(0, [2])
+
+  await compareUsers(t, users)
+})
+
+test('concurrent insert&delete (handle three conflicts)', async function array3 (t) {
+  var { users, array0, array1, array2 } = await initArrays(t, { users: 3 })
+  array0.insert(0, ['x', 'y', 'z'])
+  await flushAll(t, users)
+  array0.insert(1, [0])
+  array1.delete(0)
+  array1.delete(1, 1)
+  array2.insert(1, [2])
+
+  await compareUsers(t, users)
+})
+
+test('insertions work in late sync', async function array4 (t) {
+  var { users, array0, array1, array2 } = await initArrays(t, { users: 3 })
+  array0.insert(0, ['x', 'y'])
+  await flushAll(t, users)
+  users[1].disconnect()
+  users[2].disconnect()
+  array0.insert(1, ['user0'])
+  array1.insert(1, ['user1'])
+  array2.insert(1, ['user2'])
+  await users[1].reconnect()
+  await users[2].reconnect()
+  await compareUsers(t, users)
+})
+
+test('disconnect really prevents sending messages', async function array5 (t) {
+  var { users, array0, array1 } = await initArrays(t, { users: 3 })
+  array0.insert(0, ['x', 'y'])
+  await flushAll(t, users)
+  users[1].disconnect()
+  users[2].disconnect()
+  array0.insert(1, ['user0'])
+  array1.insert(1, ['user1'])
+  await wait(1000)
+  t.compare(array0.toArray(), ['x', 'user0', 'y'])
+  t.compare(array1.toArray(), ['x', 'user1', 'y'])
+  await users[1].reconnect()
+  await users[2].reconnect()
+  await compareUsers(t, users)
+})
+
+test('deletions in late sync', async function array6 (t) {
+  var { users, array0, array1 } = await initArrays(t, { users: 2 })
+  array0.insert(0, ['x', 'y'])
+  await flushAll(t, users)
+  await users[1].disconnect()
+  array1.delete(1, 1)
+  array0.delete(0, 2)
+  await wait()
+  await users[1].reconnect()
+  await compareUsers(t, users)
+})
+
+test('insert, then marge delete on sync', async function array7 (t) {
+  var { users, array0, array1 } = await initArrays(t, { users: 2 })
+  array0.insert(0, ['x', 'y', 'z'])
+  await flushAll(t, users)
+  await wait()
+  await users[0].disconnect()
+  array1.delete(0, 3)
+  await wait()
+  await users[0].reconnect()
+  await compareUsers(t, users)
+})
+
+function compareEvent (t, is, should) {
+  for (var key in should) {
+    t.assert(
+      should[key] === is[key] ||
+      JSON.stringify(should[key]) === JSON.stringify(is[key])
+    , 'event works as expected'
+    )
+  }
+}
+
+test('insert & delete events', async function array8 (t) {
+  var { array0, users } = await initArrays(t, { users: 2 })
+  var event
+  array0.observe(function (e) {
+    event = e
+  })
+  array0.insert(0, [0, 1, 2])
+  compareEvent(t, event, {
+    type: 'insert',
+    index: 0,
+    values: [0, 1, 2],
+    length: 3
+  })
+  array0.delete(0)
+  compareEvent(t, event, {
+    type: 'delete',
+    index: 0,
+    length: 1,
+    values: [0]
+  })
+  array0.delete(0, 2)
+  compareEvent(t, event, {
+    type: 'delete',
+    index: 0,
+    length: 2,
+    values: [1, 2]
+  })
+  await compareUsers(t, users)
+})
+
+test('insert & delete events for types', async function array9 (t) {
+  var { array0, users } = await initArrays(t, { users: 2 })
+  var event
+  array0.observe(function (e) {
+    event = e
+  })
+  array0.insert(0, [Y.Array])
+  compareEvent(t, event, {
+    type: 'insert',
+    object: array0,
+    index: 0,
+    length: 1
+  })
+  var type = array0.get(0)
+  t.assert(type._model != null, 'Model of type is defined')
+  array0.delete(0)
+  compareEvent(t, event, {
+    type: 'delete',
+    object: array0,
+    index: 0,
+    length: 1
+  })
+  await compareUsers(t, users)
+})
+
+test('insert & delete events for types (2)', async function array10 (t) {
+  var { array0, users } = await initArrays(t, { users: 2 })
+  var events = []
+  array0.observe(function (e) {
+    events.push(e)
+  })
+  array0.insert(0, ['hi', Y.Map])
+  compareEvent(t, events[0], {
+    type: 'insert',
+    object: array0,
+    index: 0,
+    length: 1,
+    values: ['hi']
+  })
+  compareEvent(t, events[1], {
+    type: 'insert',
+    object: array0,
+    index: 1,
+    length: 1
+  })
+  array0.delete(1)
+  compareEvent(t, events[2], {
+    type: 'delete',
+    object: array0,
+    index: 1,
+    length: 1
+  })
+  await compareUsers(t, users)
+})
+
+test('garbage collector', async function gc1 (t) {
+  var { users, array0 } = await initArrays(t, { users: 3 })
+
+  array0.insert(0, ['x', 'y', 'z'])
+  await flushAll(t, users)
+  users[0].disconnect()
+  array0.delete(0, 3)
+  await wait()
+  await users[0].reconnect()
+  await flushAll(t, users)
+  await garbageCollectUsers(t, users)
+  await compareUsers(t, users)
+})
+
+test('event has correct value when setting a primitive on a YArray (same user)', async function array11 (t) {
+  var { array0, users } = await initArrays(t, { users: 3 })
+
+  var event
+  array0.observe(function (e) {
+    event = e
+  })
+  array0.insert(0, ['stuff'])
+  t.assert(event.values[0] === event.object.get(0), 'compare value with get method')
+  t.assert(event.values[0] === 'stuff', 'check that value is actually present')
+  t.assert(event.values[0] === array0.toArray()[0], '.toArray works as expected')
+  await compareUsers(t, users)
+})
+
+test('event has correct value when setting a primitive on a YArray (received from another user)', async function array12 (t) {
+  var { users, array0, array1 } = await initArrays(t, { users: 3 })
+
+  var event
+  array0.observe(function (e) {
+    event = e
+  })
+  array1.insert(0, ['stuff'])
+  await flushAll(t, users)
+  t.assert(event.values[0] === event.object.get(0), 'compare value with get method')
+  t.assert(event.values[0] === 'stuff', 'check that value is actually present')
+  t.assert(event.values[0] === array0.toArray()[0], '.toArray works as expected')
+  await compareUsers(t, users)
+})
+
+test('event has correct value when setting a type on a YArray (same user)', async function array13 (t) {
+  var { array0, users } = await initArrays(t, { users: 3 })
+
+  var event
+  array0.observe(function (e) {
+    event = e
+  })
+  array0.insert(0, [Y.Array])
+  t.assert(event.values[0] === event.object.get(0), 'compare value with get method')
+  t.assert(event.values[0] != null, 'event.value exists')
+  t.assert(event.values[0] === array0.toArray()[0], '.toArray works as expected')
+  await compareUsers(t, users)
+})
+test('event has correct value when setting a type on a YArray (ops received from another user)', async function array14 (t) {
+  var { users, array0, array1 } = await initArrays(t, { users: 3 })
+
+  var event
+  array0.observe(function (e) {
+    event = e
+  })
+  array1.insert(0, [Y.Array])
+  await flushAll(t, users)
+  t.assert(event.values[0] === event.object.get(0), 'compare value with get method')
+  t.assert(event.values[0] != null, 'event.value exists')
+  t.assert(event.values[0] === array0.toArray()[0], '.toArray works as expected')
+  await compareUsers(t, users)
+})
+
+var _uniqueNumber = 0
+function getUniqueNumber () {
+  return _uniqueNumber++
+}
+
+var arrayTransactions = [
+  function insert (t, user, chance) {
+    var uniqueNumber = getUniqueNumber()
+    var content = []
+    var len = chance.integer({ min: 1, max: 4 })
+    for (var i = 0; i < len; i++) {
+      content.push(uniqueNumber)
+    }
+    var pos = chance.integer({ min: 0, max: user.share.array.length })
+    user.share.array.insert(pos, content)
+  },
+  function insertTypeArray (t, user, chance) {
+    var pos = chance.integer({ min: 0, max: user.share.array.length })
+    user.share.array.insert(pos, [Y.Array])
+    var array2 = user.share.array.get(pos)
+    array2.insert(0, [1, 2, 3, 4])
+  },
+  function insertTypeMap (t, user, chance) {
+    var pos = chance.integer({ min: 0, max: user.share.array.length })
+    user.share.array.insert(pos, [Y.Map])
+    var map = user.share.array.get(pos)
+    map.set('someprop', 42)
+    map.set('someprop', 43)
+    map.set('someprop', 44)
+  },
+  function _delete (t, user, chance) {
+    var length = user.share.array._content.length
+    if (length > 0) {
+      var pos = chance.integer({ min: 0, max: length - 1 })
+      var delLength = chance.integer({ min: 1, max: Math.min(2, length - pos) })
+      if (user.share.array._content[pos].type != null) {
+        if (chance.bool()) {
+          var type = user.share.array.get(pos)
+          if (type instanceof Y.Array.typeDefinition.class) {
+            if (type._content.length > 0) {
+              pos = chance.integer({ min: 0, max: type._content.length - 1 })
+              delLength = chance.integer({ min: 0, max: Math.min(2, type._content.length - pos) })
+              type.delete(pos, delLength)
+            }
+          } else {
+            type.delete('someprop')
+          }
+        } else {
+          user.share.array.delete(pos, delLength)
+        }
+      } else {
+        user.share.array.delete(pos, delLength)
+      }
+    }
+  }
+]
+
+test('y-array: Random tests (42)', async function randomArray42 (t) {
+  await applyRandomTests(t, arrayTransactions, 42)
+})
+
+test('y-array: Random tests (43)', async function randomArray43 (t) {
+  await applyRandomTests(t, arrayTransactions, 43)
+})
+
+test('y-array: Random tests (44)', async function randomArray44 (t) {
+  await applyRandomTests(t, arrayTransactions, 44)
+})
+
+test('y-array: Random tests (45)', async function randomArray45 (t) {
+  await applyRandomTests(t, arrayTransactions, 45)
+})
+
+test('y-array: Random tests (46)', async function randomArray46 (t) {
+  await applyRandomTests(t, arrayTransactions, 46)
+})
+
+test('y-array: Random tests (47)', async function randomArray47 (t) {
+  await applyRandomTests(t, arrayTransactions, 47)
+})
+
+/*
+test('y-array: Random tests (200)', async function randomArray200 (t) {
+  await applyRandomTests(t, arrayTransactions, 200)
+})
+
+test('y-array: Random tests (300)', async function randomArray300 (t) {
+  await applyRandomTests(t, arrayTransactions, 300)
+})
+
+test('y-array: Random tests (400)', async function randomArray400 (t) {
+  await applyRandomTests(t, arrayTransactions, 400)
+})
+
+test('y-array: Random tests (500)', async function randomArray500 (t) {
+  await applyRandomTests(t, arrayTransactions, 500)
+})
+*/
--- a/Show More
+++ b/Show More