13.0.2

add type definition for YText.length
13.0.1
2020-02-03 12:23:39 +01:00 · 2020-02-03 12:22:35 +01:00 · 2020-01-27 03:43:45 +01:00 · 2020-01-27 03:42:32 +01:00 · 2020-01-23 22:49:04 +01:00 · 2020-01-23 21:53:02 +01:00
49 changed files with 4152 additions and 4129 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: dmonad
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/.jsdoc.json
+++ b/.jsdoc.json
@@ -17,7 +17,7 @@
    "useCollapsibles": true,
    "collapse": true,
    "resources": {
-      "y-js.org": "yjs.website"
+      "yjs.dev": "Yjs website"
    },
    "logo": {
      "url": "https://user-images.githubusercontent.com/5553757/48975307-61efb100-f06d-11e8-9177-ee895e5916e5.png",
--- a/.markdownlint.json
+++ b/.markdownlint.json
@@ -0,0 +1,4 @@
+{
+  "default": true,
+  "no-inline-html": false
+}
--- a/README.md
+++ b/README.md
--- a/README.v13.md
+++ b/README.v13.md
@@ -1,559 +0,0 @@
-# ![Yjs](https://user-images.githubusercontent.com/5553757/48975307-61efb100-f06d-11e8-9177-ee895e5916e5.png)
-> A CRDT framework with a powerful abstraction of shared data
-
-Yjs is a [CRDT implementation](#Yjs-CRDT-Algorithm) that exposes its internal data structure as *shared types*. Shared types are common data types like `Map` or `Array` with superpowers: changes are automatically distributed to other peers and merged without merge conflicts.
-
-Yjs is **network agnostic** (p2p!), supports many existing **rich text editors**, **offline editing**, **version snapshots**, **undo/redo** and **shared cursors**. It scales well with an unlimited number of users and is well suited for even large documents.
-
-* Chat: [https://gitter.im/y-js/yjs](https://gitter.im/y-js/yjs)
-* Demos: [https://github.com/y-js/yjs-demos](https://github.com/y-js/yjs-demos)
-* Benchmarks: [https://github.com/dmonad/crdt-benchmarks](https://github.com/dmonad/crdt-benchmarks)
-
-# Table of Contents
-
-* [Overview](#Overview)
-  * [Bindings](#Bindings)
-  * [Providers](#Providers)
-* [Getting Started](#Getting-Started)
-* [API](#API)
-  * [Shared Types](#Shared-Types)
-  * [Y.Doc](#Y.Doc)
-  * [Document Updates](#Document-Updates)
-  * [Relative Positions](#Relative-Positions)
-* [Miscellaneous](#Miscellaneous)
-  * [Typescript Declarations](#Typescript-Declarations)
-* [Yjs CRDT Algorithm](#Yjs-CRDT-Algorithm)
-* [Evaluation](#Evaluation)
-  * [Existing shared editing libraries](#Exisisting-Javascript-Libraries)
-  * [CRDT Algorithms](#CRDT-Algorithms)
-  * [Comparison of CRDT with OT](#Comparing-CRDT-with-OT)
-  * [Comparison of CRDT Algorithms](#Comparing-CRDT-Algorithms)
-  * [Comparison of Yjs with other Implementations](#Comparing-Yjs-with-other-Implementations)
-* [License and Author](#License-and-Author)
-
-
-## Overview
-
-This repository contains a collection of shared types that can be observed for changes and manipulated concurrently. Network functionality and two-way-bindings are implemented in separate modules.
-
-### Bindings
-
-| Name &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; | Cursors | Binding |  Demo |
-|---|:-:|---|---|
-| [ProseMirror](https://prosemirror.net/) | ✔ | [y-prosemirror](http://github.com/y-js/y-prosemirror) | [demo](https://yjs-demos.now.sh/prosemirror/) |
-| [Quill](https://quilljs.com/) |  | [y-quill](http://github.com/y-js/y-quill) | [demo](https://yjs-demos.now.sh/quill/) |
-| [CodeMirror](https://codemirror.net/) | ✔ | [y-codemirror](http://github.com/y-js/y-codemirror) | [demo](https://yjs-demos.now.sh/codemirror/) |
-| [Monaco](https://microsoft.github.io/monaco-editor/) | ✔ | [y-monaco](http://github.com/y-js/y-monaco) | [demo](https://yjs-demos.now.sh/monaco/) |
-| [Ace](https://ace.c9.io/) | | [y-ace](http://github.com/y-js/y-ace) | [demo](https://yjs-demos.now.sh/ace/) |
-| [Textarea](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/textarea) | | [y-textarea](http://github.com/y-js/y-textarea) | [demo](https://yjs-demos.now.sh/textarea/) |
-| [DOM](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) | | [y-dom](http://github.com/y-js/y-dom) | [demo](https://yjs-demos.now.sh/dom/) |
-
-
-### Providers
-
-Setting up the communication between clients, managing awareness information, and storing shared data for offline usage is quite a hassle. **Providers** manage all that for you and are the perfect starting point for your collaborative app.
-
-<dl>
-  <dt><a href="http://github.com/y-js/y-websocket">y-websocket</a></dt>
-  <dd>A module that contains a simple websocket backend and a websocket client that connects to that backend. The backend can be extended to persist updates in a leveldb database.</dd>
-  <dt><a href="http://github.com/y-js/y-mesh">y-mesh</a></dt>
-  <dd>[WIP] Creates a connected graph of webrtc connections with a high <a href="https://en.wikipedia.org/wiki/Strength_of_a_graph">strength</a>. It requires a signalling server that connects a client to the first peer. But after that the network manages itself. It is well suited for large and small networks.</dd>
-  <dt><a href="http://github.com/y-js/y-dat">y-dat</a></dt>
-  <dd>[WIP] Write document updates effinciently to the dat network using <a href="https://github.com/kappa-db/multifeed">multifeed</a>. Each client has an append-only log of CRDT local updates (hypercore). Multifeed manages and sync hypercores and y-dat listens to changes and applies them to the Yjs document.</dd>
-</dl>
-
-## Getting Started
-
-Install Yjs and a provider with your favorite package manager.
-
-```sh
-npm i yjs@13.0.0-82 y-websocket@1.0.0-3 y-textarea
-```
-
-**Start the y-websocket server**
-
-```sh
-PORT=1234 node ./node_modules/y-websocket/bin/server.js
-```
-
-**Example: Textarea Binding**
-
-This is a complete example on how to create a connection to a [y-websocket](https://github.com/y-js/y-websocket) server instance, sync the shared document to all clients in a *room*, and bind a Y.Text type to a dom textarea. All changes to the textarea are automatically shared with everyone in the same room.
-
-```js
-import * as Y from 'yjs'
-import { WebsocketProvider } from 'y-websocket'
-import { TextareaBinding } from 'y-textarea'
-
-const doc = Y.Doc()
-const provider = new WebsocketProvider('http://localhost:1234', 'roomname')
-// sync all document updates through the websocket connection
-provider.sync('doc')
-
-// Define a shared type on the document.
-const ytext = doc.getText('my resume')
-
-// use data bindings to bind types to editors
-const binding = new TextareaBinding(ytext, document.querySelector('textarea'))
-```
-
-**Example: Observe types**
-
-```js
-const yarray = doc.getArray('my-array')
-yarray.observe(event => {
-  console.log('yarray was modified')
-})
-// every time a local or remote client modifies yarray, the observer is called
-yarray.insert(0, ['val']) // => "yarray was modified"
-```
-
-**Example: Nest types**
-
-Remember, shared types are just plain old data types. The only limitation is that a shared type must exist only once in the shared document.
-
-```js
-const ymap = doc.getMap('map')
-const foodArray = new Y.Array()
-foodArray.insert(0, ['apple', 'banana'])
-ymap.set('food', foodArray)
-ymap.get('food') === foodArray // => true
-ymap.set('fruit', foodArray) // => Error! foodArray is already defined on the shared document
-```
-
-Now you understand how types are defined on a shared document. Next you can jump to the [demo repository](https://github.com/y-js/yjs-demos) or continue reading the API docs.
-
-## API
-
-```js
-import * as Y from 'yjs'
-```
-
-### Shared Types
-
-<details>
-  <summary><b>Y.Array</b></summary>
-  <br>
-  <p>
-    A shareable Array-like type that supports efficient insert/delete of elements at any position. Internally it uses a linked list of Arrays that is split when necessary.
-  </p>
-  <pre>const yarray = new Y.Array()</pre>
-  <dl>
-    <b><code>insert(index:number, content:Array&lt;object|boolean|Array|string|number|Uint8Array|Y.Type&gt;)</code></b>
-    <dd>
-      Insert content at <var>index</var>. Note that content is an array of elements. I.e. <code>array.insert(0, [1]</code> splices the list and inserts 1 at position 0.
-    </dd>
-    <b><code>push(Array&lt;Object|boolean|Array|string|number|Uint8Array|Y.Type&gt;)</code></b>
-    <dd></dd>
-    <b><code>delete(index:number, length:number)</code></b>
-    <dd></dd>
-    <b><code>get(index:number)</code></b>
-    <dd></dd>
-    <b><code>length:number</code></b>
-    <dd></dd>
-    <b><code>map(function(T, number, YArray):M):Array&lt;M&gt;</code></b>
-    <dd></dd>
-    <b><code>toArray():Array&lt;object|boolean|Array|string|number|Uint8Array|Y.Type&gt;</code></b>
-    <dd>Copies the content of this YArray to a new Array.</dd>
-    <b><code>toJSON():Array&lt;Object|boolean|Array|string|number&gt;</code></b>
-    <dd>Copies the content of this YArray to a new Array. It transforms all child types to JSON using their <code>toJSON</code> method.</dd>
-    <b><code>[Symbol.Iterator]</code></b>
-    <dd>
-      Returns an YArray Iterator that contains the values for each index in the array.
-      <pre>for (let value of yarray) { .. }</pre>
-    </dd>
-    <b><code>observe(function(YArrayEvent, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
-    </dd>
-    <b><code>unobserve(function(YArrayEvent, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observe</code> event listener from this type.
-    </dd>
-    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
-    </dd>
-    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observeDeep</code> event listener from this type.
-    </dd>
-  </dl>
-</details>
-<details>
-  <summary><b>Y.Map</b></summary>
-  <br>
-  <p>
-    A shareable Map type.
-  </p>
-  <pre><code>const ymap = new Y.Map()</code></pre>
-  <dl>
-    <b><code>get(key:string):object|boolean|string|number|Uint8Array|Y.Type</code></b>
-    <dd></dd>
-    <b><code>set(key:string, value:object|boolean|string|number|Uint8Array|Y.Type)</code></b>
-    <dd></dd>
-    <b><code>delete(key:string)</code></b>
-    <dd></dd>
-    <b><code>has(key:string):boolean</code></b>
-    <dd></dd>
-    <b><code>get(index:number)</code></b>
-    <dd></dd>
-    <b><code>toJSON():Object&lt;string, Object|boolean|Array|string|number&gt;</code></b>
-    <dd>Copies the <code>[key,value]</code> pairs of this YMap to a new Object. It transforms all child types to JSON using their <code>toJSON</code> method.</dd>
-    <b><code>[Symbol.Iterator]</code></b>
-    <dd>
-      Returns an Iterator of <code>[key, value]</code> pairs.
-      <pre>for (let [key, value] of ymap) { .. }</pre>
-    </dd>
-    <b><code>entries()</code></b>
-    <dd>
-      Returns an Iterator of <code>[key, value]</code> pairs.
-    </dd>
-    <b><code>values()</code></b>
-    <dd>
-      Returns an Iterator of all values.
-    </dd>
-    <b><code>keys()</code></b>
-    <dd>
-      Returns an Iterator of all keys.
-    </dd>
-    <b><code>observe(function(YMapEvent, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
-    </dd>
-    <b><code>unobserve(function(YMapEvent, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observe</code> event listener from this type.
-    </dd>
-    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
-    </dd>
-    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observeDeep</code> event listener from this type.
-    </dd>
-  </dl>
-</details>
-
-<details>
-  <summary><b>Y.Text</b></summary>
-  <br>
-  <p>
-    A shareable type that is optimized for shared editing on text. It allows to assign properties to ranges in the text. This makes it possible to implement rich-text bindings to this type.
-  </p>
-  <p>
-    This type can also be transformed to the <a href="https://quilljs.com/docs/delta">delta format</a>. Similarly the YTextEvents compute changes as deltas.
-  </p>
-  <pre>const ytext = new Y.Text()</pre>
-  <dl>
-    <b><code>insert(index:number, content:string, [formattingAttributes:Object&lt;string,string&gt;])</code></b>
-    <dd>
-      Insert a string at <var>index</var> and assign formatting attributes to it.
-      <pre>ytext.insert(0, 'bold text', { bold: true })</pre>
-    </dd>
-    <b><code>delete(index:number, length:number)</code></b>
-    <dd></dd>
-    <b><code>format(index:number, length:number, formattingAttributes:Object&lt;string,string&gt;)</code></b>
-    <dd>Assign formatting attributes to a range in the text</dd>
-    <b><code>applyDelta(delta)</code></b>
-    <dd>See <a href="https://quilljs.com/docs/delta/">Quill Delta</a></dd>
-    <b><code>length:number</code></b>
-    <dd></dd>
-    <b><code>toString():string</code></b>
-    <dd>Transforms this type, without formatting options, into a string.</dd>
-    <b><code>toJSON():string</code></b>
-    <dd>See <code>toString</code></dd>
-    <b><code>toDelta():Delta</code></b>
-    <dd>Transforms this type to a <a href="https://quilljs.com/docs/delta/">Quill Delta</a></dd>
-    <b><code>observe(function(YTextEvent, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
-    </dd>
-    <b><code>unobserve(function(YTextEvent, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observe</code> event listener from this type.
-    </dd>
-    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
-    </dd>
-    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observeDeep</code> event listener from this type.
-    </dd>
-  </dl>
-</details>
-
-<details>
-  <summary><b>YXmlFragment</b></summary>
-  <br>
-  <p>
-    A container that holds an Array of Y.XmlElements.
-  </p>
-  <pre><code>const yxml = new Y.XmlFragment()</code></pre>
-  <dl>
-    <b><code>insert(index:number, content:Array&lt;Y.XmlElement|Y.XmlText&gt;)</code></b>
-    <dd></dd>
-    <b><code>delete(index:number, length:number)</code></b>
-    <dd></dd>
-    <b><code>get(index:number)</code></b>
-    <dd></dd>
-    <b><code>length:number</code></b>
-    <dd></dd>
-    <b><code>toArray():Array&lt;Y.XmlElement|Y.XmlText&gt;</code></b>
-    <dd>Copies the children to a new Array.</dd>
-    <b><code>toDOM():DocumentFragment</code></b>
-    <dd>Transforms this type and all children to new DOM elements.</dd>
-    <b><code>toString():string</code></b>
-    <dd>Get the XML serialization of all descendants.</dd>
-    <b><code>toJSON():string</code></b>
-    <dd>See <code>toString</code>.</dd>
-    <b><code>observe(function(YXmlEvent, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
-    </dd>
-    <b><code>unobserve(function(YXmlEvent, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observe</code> event listener from this type.
-    </dd>
-    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
-    </dd>
-    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observeDeep</code> event listener from this type.
-    </dd>
-  </dl>
-</details>
-
-<details>
-  <summary><b>Y.XmlElement</b></summary>
-  <br>
-  <p>
-    A shareable type that represents an XML Element. It has a <code>nodeName</code>, attributes, and a list of children. But it makes no effort to validate its content and be actually XML compliant.
-  </p>
-  <pre><code>const yxml = new Y.XmlElement()</code></pre>
-  <dl>
-    <b><code>insert(index:number, content:Array&lt;Y.XmlElement|Y.XmlText&gt;)</code></b>
-    <dd></dd>
-    <b><code>delete(index:number, length:number)</code></b>
-    <dd></dd>
-    <b><code>get(index:number)</code></b>
-    <dd></dd>
-    <b><code>length:number</code></b>
-    <dd></dd>
-    <b><code>setAttribute(attributeName:string, attributeValue:string)</code></b>
-    <dd></dd>
-    <b><code>removeAttribute(attributeName:string)</code></b>
-    <dd></dd>
-    <b><code>getAttribute(attributeName:string):string</code></b>
-    <dd></dd>
-    <b><code>getAttributes(attributeName:string):Object&lt;string,string&gt;</code></b>
-    <dd></dd>
-    <b><code>toArray():Array&lt;Y.XmlElement|Y.XmlText&gt;</code></b>
-    <dd>Copies the children to a new Array.</dd>
-    <b><code>toDOM():Element</code></b>
-    <dd>Transforms this type and all children to a new DOM element.</dd>
-    <b><code>toString():string</code></b>
-    <dd>Get the XML serialization of all descendants.</dd>
-    <b><code>toJSON():string</code></b>
-    <dd>See <code>toString</code>.</dd>
-    <b><code>observe(function(YXmlEvent, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
-    </dd>
-    <b><code>unobserve(function(YXmlEvent, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observe</code> event listener from this type.
-    </dd>
-    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
-    </dd>
-    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
-    <dd>
-      Removes an <code>observeDeep</code> event listener from this type.
-    </dd>
-  </dl>
-</details>
-
-### Y.Doc
-
-```js
-const doc = new Y.Doc()
-```
-
-<dl>
-  <b><code>clientID</code></b>
-  <dd>A unique id that identifies this client. (readonly)</dd>
-  <b><code>transact(function(Transaction):void [, origin:any])</code></b>
-  <dd>Every change on the shared document happens in a transaction. Observer calls and the <code>update</code> event are called after each transaction. You should <i>bundle</i> changes into a single transaction to reduce the amount of event calls. I.e. <code>doc.transact(() => { yarray.insert(..); ymap.set(..) })</code> triggers a single change event. <br>You can specify an optional <code>origin</code> parameter that is stored on <code>transaction.origin</code> and <code>on('update', (update, origin) => ..)</code>.</dd>
-  <b><code>get(string, Y.[TypeClass]):[Type]</code></b>
-  <dd>Define a shared type.</dd>
-  <b><code>getArray(string):Y.Array</code></b>
-  <dd>Define a shared Y.Array type. Is equivalent to <code>y.get(string, Y.Array)</code>.</dd>
-  <b><code>getMap(string):Y.Map</code></b>
-  <dd>Define a shared Y.Map type. Is equivalent to <code>y.get(string, Y.Map)</code>.</dd>
-  <b><code>getXmlFragment(string):Y.XmlFragment</code></b>
-  <dd>Define a shared Y.XmlFragment type. Is equivalent to <code>y.get(string, Y.XmlFragment)</code>.</dd>
-  <b><code>on(string, function)</code></b>
-  <dd>Register an event listener on the shared type</dd>
-  <b><code>off(string, function)</code></b>
-  <dd>Unregister an event listener from the shared type</dd>
-</dl>
-
-
-#### Y.Doc Events
-<dl>
-  <b><code>on('update', function(updateMessage:Uint8Array, origin:any, Y.Doc):void)</code></b>
-  <dd>Listen to document updates. Document updates must be transmitted to all other peers. You can apply document updates in any order and multiple times.</dd>
-  <b><code>on('beforeTransaction', function(Y.Transaction, Y.Doc):void)</code></b>
-  <dd>Emitted before each transaction.</dd>
-  <b><code>on('afterTransaction', function(Y.Transaction, Y.Doc):void)</code></b>
-  <dd>Emitted after each transaction.</dd>
-</dl>
-
-### Document Updates
-
-Changes on the shared document are encoded into *document updates*. Document updates are *commutative* and *idempotent*. This means that they can be applied in any order and multiple times.
-
-**Example: Listen to update events and apply them on remote client**
-```js
-const doc1 = new Y.Doc()
-const doc2 = new Y.Doc()
-
-doc1.on('update', update => {
-  Y.applyUpdate(doc2, update)
-})
-
-doc2.on('update', update => {
-  Y.applyUpdate(doc1, update)
-})
-
-// All changes are also applied to the other document
-doc1.getArray('myarray').insert(0, ['Hello doc2, you got this?'])
-doc2.getArray('myarray').get(0) // => 'Hello doc2, you got this?'
-```
-
-Yjs internally maintains a [state vector](#State-Vector) that denotes the next expected clock from each client. In a different interpretation it holds the number of structs created by each client. When two clients sync, you can either exchange the complete document structure or only the differences by sending the state vector to compute the differences.
-
-**Example: Sync two clients by exchanging the complete document structure**
-
-```js
-const state1 = Y.encodeStateAsUpdate(ydoc1)
-const state2 = Y.encodeStateAsUpdate(ydoc2)
-Y.applyUpdate(ydoc1, state2)
-Y.applyUpdate(ydoc2, state1)
-```
-
-**Example: Sync two clients by computing the differences**
-
-This example shows how to sync two clients with the minimal amount of exchanged data by computing only the differences using the state vector of the remote client. Syncing clients using the state vector requires another roundtrip, but can safe a lot of bandwidth.
-
-```js
-const stateVector1 = Y.encodeStateVector(ydoc1)
-const stateVector2 = Y.encodeStateVector(ydoc2)
-const diff1 = Y.encodeStateAsUpdate(ydoc1, stateVector2)
-const diff2 = Y.encodeStateAsUpdate(ydoc2, stateVector1)
-Y.applyUpdate(ydoc1, diff2)
-Y.applyUpdate(ydoc2, diff1)
-```
-
-<dl>
-  <b><code>Y.applyUpdate(Y.Doc, update:Uint8Array, [transactionOrigin:any])</code></b>
-  <dd>Apply a document update on the shared document. Optionally you can specify <code>transactionOrigin</code> that will be stored on <code>transaction.origin</code> and <code>ydoc.on('update', (update, origin) => ..)</code>.</dd>
-  <b><code>Y.encodeStateAsUpdate(Y.Doc, [encodedTargetStateVector:Uint8Array]):Uint8Array</code></b>
-  <dd>Encode the document state as a single update message that can be applied on the remote document. Optionally specify the target state vector to only write the differences to the update message.</dd>
-  <b><code>Y.encodeStateVector(Y.Doc):Uint8Array</code></b>
-  <dd>Computes the state vector and encodes it into an Uint8Array.</dd>
-</dl>
-
-### Relative Positions
-> This API is not stable yet
-
-This feature is intended for managing selections / cursors. When working with other users that manipulate the shared document, you can't trust that an index position (an integer) will stay at the intended location. A *relative position* is fixated to an element in the shared document and is not affected by remote changes. I.e. given the document `"a|c"`, the relative position is attached to `c`. When a remote user modifies the document by inserting a character before the cursor, the cursor will stay attached to the character `c`. `insert(1, 'x')("a|c") = "ax|c"`. When the *relative position* is set to the end of the document, it will stay attached to the end of the document.
-
-**Example: Transform to RelativePosition and back**
-```js
-const relPos = Y.createRelativePositionFromTypeIndex(ytext, 2)
-const pos = Y.createAbsolutePositionFromRelativePosition(relPos, doc)
-pos.type === ytext // => true
-pos.index === 2 // => true
-```
-
-**Example: Send relative position to remote client (json)**
-```js
-const relPos = Y.createRelativePositionFromTypeIndex(ytext, 2)
-const encodedRelPos = JSON.stringify(relPos)
-// send encodedRelPos to remote client..
-const parsedRelPos = JSON.parse(encodedRelPos)
-const pos = Y.createAbsolutePositionFromRelativePosition(parsedRelPos, remoteDoc)
-pos.type === remoteytext // => true
-pos.index === 2 // => true
-```
-
-**Example: Send relative position to remote client (Uint8Array)**
-```js
-const relPos = Y.createRelativePositionFromTypeIndex(ytext, 2)
-const encodedRelPos = Y.encodeRelativePosition(relPos)
-// send encodedRelPos to remote client..
-const parsedRelPos = Y.decodeRelativePosition(encodedRelPos)
-const pos = Y.createAbsolutePositionFromRelativePosition(parsedRelPos, remoteDoc)
-pos.type === remoteytext // => true
-pos.index === 2 // => true
-```
-
-<dl>
-  <b><code>Y.createRelativePositionFromTypeIndex(Uint8Array|Y.Type, number)</code></b>
-  <dd></dd>
-  <b><code>Y.createAbsolutePositionFromRelativePosition(RelativePosition, Y.Doc)</code></b>
-  <dd></dd>
-  <b><code>Y.encodeRelativePosition(RelativePosition):Uint8Array</code></b>
-  <dd></dd>
-  <b><code>Y.decodeRelativePosition(Uint8Array):RelativePosition</code></b>
-  <dd></dd>
-</dl>
-
-## Miscellaneous
-
-### Typescript Declarations
-
-Yjs has type descriptions. But until [this ticket](https://github.com/Microsoft/TypeScript/issues/7546) is fixed, this is how you can make use of Yjs type declarations.
-
-```json
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "checkJs": true,
-  },
-  "maxNodeModuleJsDepth": 5
-}
-```
-
-## Yjs CRDT Algorithm
-
-*Conflict-free replicated data types* (CRDT) for collaborative editing are an alternative approach to *operational transformation* (OT). A very simple differenciation between the two approaches is that OT attempts to transform index positions to ensure convergence (all clients end up with the same content), while CRDTs use mathematical models that usually do not involve index transformations, like linked lists. OT is currently the de-facto standard for shared editing on text. OT approaches that support shared editing without a central source of truth (a central server) require too much bookkeeping to be viable in practice. CRDTs are better suited for distributed systems, provide additional guarantees that the document can be synced with remote clients, and do not require a central source of truth.
-
-Yjs implements a modified version of the algorithm described in [this paper](https://www.researchgate.net/publication/310212186_Near_Real-Time_Peer-to-Peer_Shared_Editing_on_Extensible_Data_Types). I will eventually publish a paper that describes why this approach works so well in practice. Note: Since operations make up the document structure, we prefer the term *struct* now.
-
-CRDTs suitable for shared text editing suffer from the fact that they only grow in size. There are CRDTs that do not grow in size, but they do not have the characteristics that are benificial for shared text editing (like intention preservation). Yjs implements many improvements to the original algorithm that diminish the trade-off that the document only grows in size. We can't garbage collect deleted structs (tombstones) while ensuring a unique order of the structs. But we can 1. merge preceeding structs into a single struct to reduce the amount of meta information, 2. we can delete content from the struct if it is deleted, and 3. we can garbage collect tombstones if we don't care about the order of the structs anymore (e.g. if the parent was deleted).
-
-**Examples:**
-1. If a user inserts elements in sequence, the struct will be merged into a single struct. E.g. `array.insert(0, ['a']), array.insert(0, ['b']);` is first represented as two structs (`[{id: {client, clock: 0}, content: 'a'}, {id: {client, clock: 1}, content: 'b'}`) and then merged into a single struct: `[{id: {client, clock: 0}, content: 'ab'}]`.
-2. When a struct that contains content (e.g. `ItemString`) is deleted, the struct will be replaced with an `ItemDeleted` that does not contain content anymore.
-3. When a type is deleted, all child elements are transformed to `GC` structs. A `GC` struct only denotes the existence of a struct and that it is deleted. `GC` structs can always be merged with other `GC` structs if the id's are adjacent.
-
-Especially when working on structured content (e.g. shared editing on ProseMirror), these improvements yield very good results when [benchmarking](https://github.com/dmonad/crdt-benchmarks) random document edits. In practice they show even better results, because users usually edit text in sequence, resulting in structs that can easily be merged. The benchmarks show that even in the worst case scenario that a user edits text from right to left, Yjs achieves good performance even for huge documents.
-
-#### State Vector
-Yjs has the ability to exchange only the differences when syncing two clients. We use lamport timestamps to identify structs and to track in which order a client created them. Each struct has an `struct.id = { client: number, clock: number}` that uniquely identifies a struct. We define the next expected `clock` by each client as the *state vector*. This data structure is similar to the [version vectors](https://en.wikipedia.org/wiki/Version_vector) data structure. But we use state vectors only to describe the state of the local document, so we can compute the missing struct of the remote client. We do not use it to track causality.
-
-## License and Author
-
-Yjs and all related projects are [**MIT licensed**](./LICENSE).
-
-Yjs is based on my research as a student at the [RWTH i5](http://dbis.rwth-aachen.de/). Now I am working on Yjs in my spare time.
-
-Fund this project by donating on [Patreon](https://www.patreon.com/dmonad) or hiring [me](https://github.com/dmonad) for professional support.
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,23 +1,23 @@
 {
  "name": "yjs",
-  "version": "13.0.0-87",
+  "version": "13.0.2",
  "description": "Shared Editing Library",
-  "main": "./dist/yjs.js",
-  "module": "./dist/yjs.mjs",
+  "main": "./dist/yjs.cjs",
+  "module": "./src/index.js",
+  "types": "./dist/src/index.d.ts",
  "sideEffects": false,
  "scripts": {
-    "test": "npm run dist && PRODUCTION=1 node ./dist/tests.js --repitition-time 50 --production",
-    "test-exhaustive": "npm run lint && npm run dist && node ./dist/tests.js --repitition-time 10000",
-    "dist": "rm -rf dist && rollup -c",
+    "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": "standard && tsc",
-    "docs": "rm -rf docs; jsdoc --configure ./.jsdoc.json --verbose --readme ./README.v13.md --package ./package.json || true",
-    "serve-docs": "npm run docs && serve ./docs/",
-    "preversion": "npm run lint && PRODUCTION=1 npm run dist && npm run docs && node ./dist/tests.js --repitition-time 1000",
-    "postversion": "git push && git push --tags",
-    "debug": "concurrently 'live-server --port=3443 --entry-file=test.html' 'npm run watch'",
-    "trace-deopt": "clear && rollup -c  && node --trace-deopt dist/test.js",
-    "trace-opt": "clear && rollup -c  && node --trace-opt dist/test.js"
+    "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",
+    "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"
  },
  "files": [
    "dist/*",
@@ -38,31 +38,38 @@
  },
  "repository": {
    "type": "git",
-    "url": "https://github.com/y-js/yjs.git"
+    "url": "https://github.com/yjs/yjs.git"
  },
  "keywords": [
-    "crdt"
+    "Yjs",
+    "CRDT",
+    "offline",
+    "shared editing",
+    "concurrency",
+    "collaboration"
  ],
  "author": "Kevin Jahns",
-  "email": "kevin.jahns@rwth-aachen.de",
+  "email": "kevin.jahns@protonmail.com",
  "license": "MIT",
  "bugs": {
-    "url": "https://github.com/y-js/yjs/issues"
+    "url": "https://github.com/yjs/yjs/issues"
  },
-  "homepage": "http://y-js.org",
+  "homepage": "https://yjs.dev",
  "dependencies": {
-    "lib0": "0.0.5"
+    "lib0": "^0.2.12"
  },
  "devDependencies": {
+    "@rollup/plugin-commonjs": "^11.0.1",
+    "@rollup/plugin-node-resolve": "^7.0.0",
    "concurrently": "^3.6.1",
-    "jsdoc": "^3.6.2",
-    "live-server": "^1.2.1",
-    "rollup": "^1.11.3",
+    "http-server": "^0.12.1",
+    "jsdoc": "^3.6.3",
+    "markdownlint-cli": "^0.19.0",
+    "rollup": "^1.30.0",
    "rollup-cli": "^1.0.9",
-    "rollup-plugin-node-resolve": "^4.2.4",
-    "standard": "^11.0.1",
+    "standard": "^14.0.0",
    "tui-jsdoc-template": "^1.2.2",
-    "typescript": "^3.4.5",
-    "y-protocols": "0.0.6"
+    "typescript": "^3.7.5",
+    "y-protocols": "^0.2.0"
  }
 }
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -1,4 +1,5 @@
-import nodeResolve from 'rollup-plugin-node-resolve'
+import nodeResolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'

 const localImports = process.env.LOCALIMPORTS

@@ -37,23 +38,18 @@ const debugResolve = {

 export default [{
  input: './src/index.js',
-  output: [{
+  output: {
    name: 'Y',
-    file: 'dist/yjs.js',
+    file: 'dist/yjs.cjs',
    format: 'cjs',
    sourcemap: true,
    paths: path => {
      if (/^lib0\//.test(path)) {
-        return `lib0/dist/${path.slice(5)}`
+        return `lib0/dist/${path.slice(5, -3)}.cjs`
      }
      return path
    }
-  }, {
-    name: 'Y',
-    file: 'dist/yjs.mjs',
-    format: 'es',
-    sourcemap: true
-  }],
+  },
  external: id => /^lib0\//.test(id)
 }, {
  input: './tests/index.js',
@@ -68,6 +64,24 @@ export default [{
    nodeResolve({
      sourcemap: true,
      mainFields: ['module', 'browser', 'main']
-    })
+    }),
+    commonjs()
  ]
+}, {
+  input: './tests/index.js',
+  output: {
+    name: 'test',
+    file: 'dist/tests.cjs',
+    format: 'cjs',
+    sourcemap: true
+  },
+  plugins: [
+    debugResolve,
+    nodeResolve({
+      sourcemap: true,
+      mainFields: ['module', 'main']
+    }),
+    commonjs()
+  ],
+  external: ['isomorphic.js']
 }]
--- a/src/index.js
+++ b/src/index.js
@@ -21,6 +21,7 @@ export {
  ContentEmbed,
  ContentFormat,
  ContentJSON,
+  ContentAny,
  ContentString,
  ContentType,
  AbstractType,
@@ -36,11 +37,24 @@ export {
  compareIDs,
  getState,
  Snapshot,
+  createSnapshot,
+  createDeleteSet,
+  createDeleteSetFromStructStore,
+  snapshot,
+  emptySnapshot,
  findRootTypeKey,
  typeListToArraySnapshot,
  typeMapGetSnapshot,
  iterateDeletedStructs,
  applyUpdate,
  encodeStateAsUpdate,
-  encodeStateVector
+  encodeStateVector,
+  UndoManager,
+  decodeSnapshot,
+  encodeSnapshot,
+  isDeleted,
+  isParentOf,
+  equalSnapshots,
+  PermanentUserData, // @TODO experimental
+  tryGc
 } from './internals.js'
--- a/src/internals.js
+++ b/src/internals.js
@@ -1,13 +1,16 @@
+
 export * from './utils/DeleteSet.js'
+export * from './utils/Doc.js'
+export * from './utils/encoding.js'
 export * from './utils/EventHandler.js'
 export * from './utils/ID.js'
 export * from './utils/isParentOf.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/Doc.js'
+export * from './utils/UndoManager.js'
 export * from './utils/YEvent.js'

 export * from './types/AbstractType.js'
@@ -27,8 +30,7 @@ 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'
-
-export * from './utils/encoding.js'
--- a/src/structs/AbstractStruct.js
+++ b/src/structs/AbstractStruct.js
@@ -24,6 +24,7 @@ export class AbstractStruct {
    this.length = length
    this.deleted = false
  }
+
  /**
   * Merge this struct with the item to the right.
   * This method is already assuming that `this.id.clock + this.length === this.id.clock`.
@@ -34,6 +35,7 @@ export class AbstractStruct {
  mergeWith (right) {
    return false
  }
+
  /**
   * @param {encoding.Encoder} encoder The encoder to write data to.
   * @param {number} offset
@@ -43,6 +45,7 @@ export class AbstractStruct {
  write (encoder, offset, encodingRef) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {Transaction} transaction
   */
@@ -69,6 +72,7 @@ export class AbstractStructRef {
     */
    this.id = id
  }
+
  /**
   * @param {Transaction} transaction
   * @return {Array<ID|null>}
@@ -76,6 +80,7 @@ export class AbstractStructRef {
  getMissing (transaction) {
    return this._missing
  }
+
  /**
   * @param {Transaction} transaction
   * @param {StructStore} store
--- a/src/structs/ContentAny.js
+++ b/src/structs/ContentAny.js
@@ -0,0 +1,116 @@
+import {
+  Transaction, Item, StructStore // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+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 {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    const len = this.arr.length
+    encoding.writeVarUint(encoder, len - offset)
+    for (let i = offset; i < len; i++) {
+      const c = this.arr[i]
+      encoding.writeAny(encoder, c)
+    }
+  }
+
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 8
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentAny}
+ */
+export const readContentAny = decoder => {
+  const len = decoding.readVarUint(decoder)
+  const cs = []
+  for (let i = 0; i < len; i++) {
+    cs.push(decoding.readAny(decoder))
+  }
+  return new ContentAny(cs)
+}
--- a/src/structs/ContentBinary.js
+++ b/src/structs/ContentBinary.js
@@ -17,30 +17,35 @@ export class ContentBinary {
  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}
@@ -48,6 +53,7 @@ export class ContentBinary {
  splice (offset) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {ContentBinary} right
   * @return {boolean}
@@ -55,6 +61,7 @@ export class ContentBinary {
  mergeWith (right) {
    return false
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -75,6 +82,7 @@ export class ContentBinary {
  write (encoder, offset) {
    encoding.writeVarUint8Array(encoder, this.content)
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/ContentDeleted.js
+++ b/src/structs/ContentDeleted.js
@@ -17,30 +17,35 @@ export class ContentDeleted {
  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}
@@ -50,6 +55,7 @@ export class ContentDeleted {
    this.len = offset
    return right
  }
+
  /**
   * @param {ContentDeleted} right
   * @return {boolean}
@@ -58,6 +64,7 @@ export class ContentDeleted {
    this.len += right.len
    return true
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -66,6 +73,7 @@ export class ContentDeleted {
    addToDeleteSet(transaction.deleteSet, item.id, this.len)
    item.deleted = true
  }
+
  /**
   * @param {Transaction} transaction
   */
@@ -81,6 +89,7 @@ export class ContentDeleted {
  write (encoder, offset) {
    encoding.writeVarUint(encoder, this.len - offset)
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/ContentEmbed.js
+++ b/src/structs/ContentEmbed.js
@@ -17,30 +17,35 @@ export class ContentEmbed {
  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}
@@ -48,6 +53,7 @@ export class ContentEmbed {
  splice (offset) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {ContentEmbed} right
   * @return {boolean}
@@ -55,6 +61,7 @@ export class ContentEmbed {
  mergeWith (right) {
    return false
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -75,6 +82,7 @@ export class ContentEmbed {
  write (encoder, offset) {
    encoding.writeVarString(encoder, JSON.stringify(this.embed))
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/ContentFormat.js
+++ b/src/structs/ContentFormat.js
@@ -19,30 +19,35 @@ export class ContentFormat {
    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}
@@ -50,6 +55,7 @@ export class ContentFormat {
  splice (offset) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {ContentFormat} right
   * @return {boolean}
@@ -57,6 +63,7 @@ export class ContentFormat {
  mergeWith (right) {
    return false
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -78,6 +85,7 @@ export class ContentFormat {
    encoding.writeVarString(encoder, this.key)
    encoding.writeVarString(encoder, JSON.stringify(this.value))
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/ContentJSON.js
+++ b/src/structs/ContentJSON.js
@@ -18,30 +18,35 @@ export class ContentJSON {
     */
    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}
@@ -51,6 +56,7 @@ export class ContentJSON {
    this.arr = this.arr.slice(0, offset)
    return right
  }
+
  /**
   * @param {ContentJSON} right
   * @return {boolean}
@@ -59,6 +65,7 @@ export class ContentJSON {
    this.arr = this.arr.concat(right.arr)
    return true
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -84,6 +91,7 @@ export class ContentJSON {
      encoding.writeVarString(encoder, c === undefined ? 'undefined' : JSON.stringify(c))
    }
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/ContentString.js
+++ b/src/structs/ContentString.js
@@ -18,30 +18,35 @@ export class ContentString {
     */
    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}
@@ -51,6 +56,7 @@ export class ContentString {
    this.str = this.str.slice(0, offset)
    return right
  }
+
  /**
   * @param {ContentString} right
   * @return {boolean}
@@ -59,6 +65,7 @@ export class ContentString {
    this.str += right.str
    return true
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -79,6 +86,7 @@ export class ContentString {
  write (encoder, offset) {
    encoding.writeVarString(encoder, offset === 0 ? this.str : this.str.slice(offset))
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/ContentType.js
+++ b/src/structs/ContentType.js
@@ -44,32 +44,40 @@ 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}
@@ -77,6 +85,7 @@ export class ContentType {
  splice (offset) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {ContentType} right
   * @return {boolean}
@@ -84,6 +93,7 @@ export class ContentType {
  mergeWith (right) {
    return false
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -91,6 +101,7 @@ export class ContentType {
  integrate (transaction, item) {
    this.type._integrate(transaction.doc, item)
  }
+
  /**
   * @param {Transaction} transaction
   */
@@ -117,8 +128,8 @@ export class ContentType {
      }
    })
    transaction.changed.delete(this.type)
-    transaction.changedParentTypes.delete(this.type)
  }
+
  /**
   * @param {StructStore} store
   */
@@ -137,6 +148,7 @@ export class ContentType {
    })
    this.type._map = new Map()
  }
+
  /**
   * @param {encoding.Encoder} encoder
   * @param {number} offset
@@ -144,6 +156,7 @@ export class ContentType {
  write (encoder, offset) {
    this.type._write(encoder)
  }
+
  /**
   * @return {number}
   */
--- a/src/structs/GC.js
+++ b/src/structs/GC.js
@@ -69,6 +69,7 @@ export class GCRef extends AbstractStructRef {
     */
    this.length = decoding.readVarUint(decoder)
  }
+
  /**
   * @param {Transaction} transaction
   * @param {StructStore} store
--- a/src/structs/Item.js
+++ b/src/structs/Item.js
@@ -18,10 +18,12 @@ import {
  readContentDeleted,
  readContentBinary,
  readContentJSON,
+  readContentAny,
  readContentString,
  readContentEmbed,
  readContentFormat,
  readContentType,
+  addChangedTypeToTransaction,
  ContentType, ContentDeleted, StructStore, ID, AbstractType, Transaction // eslint-disable-line
 } from '../internals.js'

@@ -32,6 +34,49 @@ 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 = item.parent._item
+  }
+}
+
 /**
 * Split leftItem into two items
 * @param {Transaction} transaction
@@ -58,6 +103,12 @@ export const splitItem = (transaction, leftItem, diff) => {
  if (leftItem.deleted) {
    rightItem.deleted = true
  }
+  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
@@ -74,6 +125,107 @@ export const splitItem = (transaction, leftItem, 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) => {
+  if (item.redone !== null) {
+    return getItemCleanStart(transaction, item.redone)
+  }
+  let parentItem = 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 !== transaction.doc.clientID) {
+        // 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} */ (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 && leftTrace.parent._item !== parentItem) {
+        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone)
+      }
+      if (leftTrace !== null && 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 && rightTrace.parent._item !== parentItem) {
+        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone)
+      }
+      if (rightTrace !== null && rightTrace.parent._item === parentItem) {
+        right = rightTrace
+        break
+      }
+      right = right.right
+    }
+  }
+  const redoneItem = new Item(
+    nextID(transaction),
+    left, left === null ? null : left.lastId,
+    right, right === null ? null : right.id,
+    parentItem === null ? item.parent : /** @type {ContentType} */ (parentItem.content).type,
+    item.parentSub,
+    item.content.copy()
+  )
+  item.redone = redoneItem.id
+  keepItem(redoneItem, true)
+  redoneItem.integrate(transaction)
+  return redoneItem
+}
+
 /**
 * Abstract class that represents any content.
 */
@@ -135,12 +287,19 @@ export class Item extends AbstractStruct {
    /**
     * If this type's effect is reundone this type refers to the type that undid
     * this operation.
-     * @type {Item | null}
+     * @type {ID | null}
     */
    this.redone = null
+    /**
+     * @type {AbstractContent}
+     */
    this.content = content
    this.length = content.getLength()
    this.countable = content.isCountable()
+    /**
+     * If true, do not garbage collect this Item.
+     */
+    this.keep = false
  }

  /**
@@ -234,7 +393,8 @@ export class Item extends AbstractStruct {
    }
    addStruct(store, this)
    this.content.integrate(transaction, this)
-    maplib.setIfUndefined(transaction.changed, parent, set.create).add(parentSub)
+    // add parent to transaction.changed
+    addChangedTypeToTransaction(transaction, parent, parentSub)
    if ((parent._item !== null && parent._item.deleted) || (this.right !== null && parentSub !== null)) {
      // delete if parent is deleted or if this is not the current attribute value of parent
      this.delete(transaction)
@@ -265,72 +425,13 @@ export class Item extends AbstractStruct {
    return n
  }

-  /**
-   * Redoes the effect of this operation.
-   *
-   * @param {Transaction} transaction The Yjs instance.
-   * @param {Set<Item>} redoitems
-   *
-   * @private
-   */
-  redo (transaction, redoitems) {
-    if (this.redone !== null) {
-      return this.redone
-    }
-    /**
-     * @type {any}
-     */
-    let parent = this.parent
-    if (parent === null) {
-      return
-    }
-    let left, right
-    if (this.parentSub === null) {
-      // Is an array item. Insert at the old position
-      left = this.left
-      right = this
-    } else {
-      // Is a map item. Insert as current value
-      left = parent.type._map.get(this.parentSub)
-      right = null
-    }
-    // make sure that parent is redone
-    if (parent._deleted === true && parent.redone === null) {
-      // try to undo parent if it will be undone anyway
-      if (!redoitems.has(parent) || !parent.redo(transaction, redoitems)) {
-        return false
-      }
-    }
-    if (parent.redone !== null) {
-      while (parent.redone !== null) {
-        parent = parent.redone
-      }
-      // find next cloned_redo items
-      while (left !== null) {
-        if (left.redone !== null && left.redone.parent === parent) {
-          left = left.redone
-          break
-        }
-        left = left.left
-      }
-      while (right !== null) {
-        if (right.redone !== null && right.redone.parent === parent) {
-          right = right.redone
-        }
-        right = right.right
-      }
-    }
-    this.redone = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, this.parentSub, this.content.copy())
-    this.redone.integrate(transaction)
-    return true
-  }
-
  /**
   * Computes the last content address of this Item.
   */
  get lastId () {
    return createID(this.id.client, this.id.clock + this.length - 1)
  }
+
  /**
   * Try to merge two items
   *
@@ -345,9 +446,14 @@ export class Item extends AbstractStruct {
      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
@@ -460,7 +566,8 @@ export const contentRefs = [
  readContentString,
  readContentEmbed,
  readContentFormat,
-  readContentType
+  readContentType,
+  readContentAny
 ]

 /**
@@ -473,12 +580,14 @@ export class AbstractContent {
  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).
@@ -491,12 +600,14 @@ export class AbstractContent {
  isCountable () {
    throw error.methodUnimplemented()
  }
+
  /**
   * @return {AbstractContent}
   */
  copy () {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {number} offset
   * @return {AbstractContent}
@@ -504,6 +615,7 @@ export class AbstractContent {
  splice (offset) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {AbstractContent} right
   * @return {boolean}
@@ -511,6 +623,7 @@ export class AbstractContent {
  mergeWith (right) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {Transaction} transaction
   * @param {Item} item
@@ -518,18 +631,21 @@ export class AbstractContent {
  integrate (transaction, item) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {Transaction} transaction
   */
  delete (transaction) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {StructStore} store
   */
  gc (store) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @param {encoding.Encoder} encoder
   * @param {number} offset
@@ -537,6 +653,7 @@ export class AbstractContent {
  write (encoder, offset) {
    throw error.methodUnimplemented()
  }
+
  /**
   * @return {number}
   */
@@ -604,6 +721,7 @@ export class ItemRef extends AbstractStructRef {
    this.content = readItemContent(decoder, info)
    this.length = this.content.getLength()
  }
+
  /**
   * @param {Transaction} transaction
   * @param {StructStore} store
@@ -619,10 +737,11 @@ export class ItemRef extends AbstractStructRef {
      this.id = createID(id.client, id.clock + offset)
      this.left = createID(this.id.client, this.id.clock - 1)
      this.content = this.content.splice(offset)
+      this.length -= offset
    }

    const left = this.left === null ? null : getItemCleanEnd(transaction, store, this.left)
-    const right = this.right === null ? null : getItemCleanStart(transaction, store, this.right)
+    const right = this.right === null ? null : getItemCleanStart(transaction, this.right)
    let parent = null
    let parentSub = this.parentSub
    if (this.parent !== null) {
--- a/src/types/AbstractType.js
+++ b/src/types/AbstractType.js
@@ -7,7 +7,7 @@ import {
  nextID,
  isVisible,
  ContentType,
-  ContentJSON,
+  ContentAny,
  ContentBinary,
  createID,
  getItemCleanStart,
@@ -30,7 +30,7 @@ import * as encoding from 'lib0/encoding.js' // eslint-disable-line
 * @param {EventType} event
 */
 export const callTypeObservers = (type, transaction, event) => {
-  callEventHandlerListeners(type._eH, event, transaction)
+  const changedType = type
  const changedParentTypes = transaction.changedParentTypes
  while (true) {
    // @ts-ignore
@@ -40,6 +40,7 @@ export const callTypeObservers = (type, transaction, event) => {
    }
    type = type._item.parent
  }
+  callEventHandlerListeners(changedType._eH, event, transaction)
 }

 /**
@@ -170,7 +171,7 @@ export class AbstractType {

  /**
   * @abstract
-   * @return {Object | Array | number | string}
+   * @return {any}
   */
  toJSON () {}
 }
@@ -369,12 +370,12 @@ export const typeListInsertGenericsAfter = (transaction, parent, referenceItem,
  let left = referenceItem
  const right = referenceItem === null ? parent._start : referenceItem.right
  /**
-   * @type {Array<Object|Array|number>}
+   * @type {Array<Object|Array<any>|number>}
   */
  let jsonContent = []
  const packJsonContent = () => {
    if (jsonContent.length > 0) {
-      left = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, new ContentJSON(jsonContent))
+      left = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, new ContentAny(jsonContent))
      left.integrate(transaction)
      jsonContent = []
    }
@@ -428,7 +429,7 @@ export const typeListInsertGenerics = (transaction, parent, index, content) => {
      if (index <= n.length) {
        if (index < n.length) {
          // insert in-between
-          getItemCleanStart(transaction, transaction.doc.store, createID(n.id.client, n.id.clock + index))
+          getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index))
        }
        break
      }
@@ -454,7 +455,7 @@ export const typeListDelete = (transaction, parent, index, length) => {
  for (; n !== null && index > 0; n = n.right) {
    if (!n.deleted && n.countable) {
      if (index < n.length) {
-        getItemCleanStart(transaction, transaction.doc.store, createID(n.id.client, n.id.clock + index))
+        getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index))
      }
      index -= n.length
    }
@@ -463,7 +464,7 @@ export const typeListDelete = (transaction, parent, index, length) => {
  while (length > 0 && n !== null) {
    if (!n.deleted) {
      if (length < n.length) {
-        getItemCleanStart(transaction, transaction.doc.store, createID(n.id.client, n.id.clock + length))
+        getItemCleanStart(transaction, createID(n.id.client, n.id.clock + length))
      }
      n.delete(transaction)
      length -= n.length
@@ -503,7 +504,7 @@ export const typeMapSet = (transaction, parent, key, value) => {
  const left = parent._map.get(key) || null
  let content
  if (value == null) {
-    content = new ContentJSON([value])
+    content = new ContentAny([value])
  } else {
    switch (value.constructor) {
      case Number:
@@ -511,10 +512,10 @@ export const typeMapSet = (transaction, parent, key, value) => {
      case Boolean:
      case Array:
      case String:
-        content = new ContentJSON([value])
+        content = new ContentAny([value])
        break
      case Uint8Array:
-        content = new ContentBinary(value)
+        content = new ContentBinary(/** @type {Uint8Array} */ (value))
        break
      default:
        if (value instanceof AbstractType) {
@@ -551,7 +552,7 @@ export const typeMapGetAll = (parent) => {
  /**
   * @type {Object<string,any>}
   */
-  let res = {}
+  const res = {}
  for (const [key, value] of parent._map) {
    if (!value.deleted) {
      res[key] = value.content.getContent()[value.length - 1]
@@ -584,7 +585,7 @@ export const typeMapHas = (parent, key) => {
 */
 export const typeMapGetSnapshot = (parent, key, snapshot) => {
  let v = parent._map.get(key) || null
-  while (v !== null && (!snapshot.sm.has(v.id.client) || v.id.clock >= (snapshot.sm.get(v.id.client) || 0))) {
+  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
--- a/src/types/YArray.js
+++ b/src/types/YArray.js
@@ -51,6 +51,7 @@ export class YArray extends AbstractType {
     */
    this._prelimContent = []
  }
+
  /**
   * Integrate this type into the Yjs instance.
   *
@@ -65,12 +66,18 @@ export class YArray extends AbstractType {
   */
  _integrate (y, item) {
    super._integrate(y, item)
-    this.insert(0, /** @type {Array} */ (this._prelimContent))
+    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.
   *
@@ -105,7 +112,7 @@ export class YArray extends AbstractType {
        typeListInsertGenerics(transaction, this, index, content)
      })
    } else {
-      /** @type {Array} */ (this._prelimContent).splice(index, 0, ...content)
+      /** @type {Array<any>} */ (this._prelimContent).splice(index, 0, ...content)
    }
  }

@@ -130,7 +137,7 @@ export class YArray extends AbstractType {
        typeListDelete(transaction, this, index, length)
      })
    } else {
-      /** @type {Array} */ (this._prelimContent).splice(index, length)
+      /** @type {Array<any>} */ (this._prelimContent).splice(index, length)
    }
  }

--- a/src/types/YMap.js
+++ b/src/types/YMap.js
@@ -53,6 +53,7 @@ export class YMap extends AbstractType {
     */
    this._prelimContent = new Map()
  }
+
  /**
   * Integrate this type into the Yjs instance.
   *
@@ -67,11 +68,16 @@ export class YMap extends AbstractType {
   */
  _integrate (y, item) {
    super._integrate(y, item)
-    for (let [key, value] of /** @type {Map<string, any>} */ (this._prelimContent)) {
+    for (const [key, value] of /** @type {Map<string, any>} */ (this._prelimContent)) {
      this.set(key, value)
    }
    this._prelimContent = null
  }
+
+  _copy () {
+    return new YMap()
+  }
+
  /**
   * Creates YMapEvent and calls observers.
   *
@@ -94,7 +100,7 @@ export class YMap extends AbstractType {
     * @type {Object<string,T>}
     */
    const map = {}
-    for (let [key, item] of this._map) {
+    for (const [key, item] of this._map) {
      if (!item.deleted) {
        const v = item.content.getContent()[item.length - 1]
        map[key] = v instanceof AbstractType ? v.toJSON() : v
@@ -106,7 +112,7 @@ export class YMap extends AbstractType {
  /**
   * Returns the keys for each element in the YMap Type.
   *
-   * @return {Iterator<string>}
+   * @return {IterableIterator<string>}
   */
  keys () {
    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[0])
@@ -115,7 +121,7 @@ export class YMap extends AbstractType {
  /**
   * Returns the keys for each element in the YMap Type.
   *
-   * @return {Iterator<string>}
+   * @return {IterableIterator<string>}
   */
  values () {
    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[1].content.getContent()[v[1].length - 1])
@@ -130,6 +136,24 @@ export class YMap extends AbstractType {
    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 overy 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 = {}
+    for (const [key, item] of this._map) {
+      if (!item.deleted) {
+        f(item.content.getContent()[item.length - 1], key, this)
+      }
+    }
+    return map
+  }
+
  /**
   * @return {IterableIterator<T>}
   */
--- a/src/types/YText.js
+++ b/src/types/YText.js
@@ -16,11 +16,20 @@ import {
  ContentEmbed,
  ContentFormat,
  ContentString,
-  Doc, Item, Snapshot, StructStore, Transaction // eslint-disable-line
+  splitSnapshotAffectedStructs,
+  ID, Doc, Item, Snapshot, Transaction // eslint-disable-line
 } from '../internals.js'

 import * as decoding from 'lib0/decoding.js' // eslint-disable-line
 import * as encoding from 'lib0/encoding.js'
+import * as object from 'lib0/object.js'
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean}
+ */
+const equalAttrs = (a, b) => a === b || (typeof a === 'object' && typeof b === 'object' && a && b && object.equalFlat(a, b))

 export class ItemListPosition {
  /**
@@ -59,7 +68,6 @@ export class ItemInsertionResult extends ItemListPosition {

 /**
 * @param {Transaction} transaction
- * @param {StructStore} store
 * @param {Map<string,any>} currentAttributes
 * @param {Item|null} left
 * @param {Item|null} right
@@ -69,7 +77,7 @@ export class ItemInsertionResult extends ItemListPosition {
 * @private
 * @function
 */
-const findNextPosition = (transaction, store, currentAttributes, left, right, count) => {
+const findNextPosition = (transaction, currentAttributes, left, right, count) => {
  while (right !== null && count > 0) {
    switch (right.content.constructor) {
      case ContentEmbed:
@@ -77,7 +85,7 @@ const findNextPosition = (transaction, store, currentAttributes, left, right, co
        if (!right.deleted) {
          if (count < right.length) {
            // split right
-            getItemCleanStart(transaction, store, createID(right.id.client, right.id.clock + count))
+            getItemCleanStart(transaction, createID(right.id.client, right.id.clock + count))
          }
          count -= right.length
        }
@@ -96,7 +104,6 @@ const findNextPosition = (transaction, store, currentAttributes, left, right, co

 /**
 * @param {Transaction} transaction
- * @param {StructStore} store
 * @param {AbstractType<any>} parent
 * @param {number} index
 * @return {ItemTextListPosition}
@@ -104,11 +111,10 @@ const findNextPosition = (transaction, store, currentAttributes, left, right, co
 * @private
 * @function
 */
-const findPosition = (transaction, store, parent, index) => {
-  let currentAttributes = new Map()
-  let left = null
-  let right = parent._start
-  return findNextPosition(transaction, store, currentAttributes, left, right, index)
+const findPosition = (transaction, parent, index) => {
+  const currentAttributes = new Map()
+  const right = parent._start
+  return findNextPosition(transaction, currentAttributes, null, right, index)
 }

 /**
@@ -130,7 +136,7 @@ const insertNegatedAttributes = (transaction, parent, left, right, negatedAttrib
    right !== null && (
      right.deleted === true || (
        right.content.constructor === ContentFormat &&
-        (negatedAttributes.get(/** @type {ContentFormat} */ (right.content).key) === /** @type {ContentFormat} */ (right.content).value)
+        equalAttrs(negatedAttributes.get(/** @type {ContentFormat} */ (right.content).key), /** @type {ContentFormat} */ (right.content).value)
      )
    )
  ) {
@@ -140,7 +146,7 @@ const insertNegatedAttributes = (transaction, parent, left, right, negatedAttrib
    left = right
    right = right.right
  }
-  for (let [key, val] of negatedAttributes) {
+  for (const [key, val] of negatedAttributes) {
    left = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, new ContentFormat(key, val))
    left.integrate(transaction)
  }
@@ -180,7 +186,7 @@ const minimizeAttributeChanges = (left, right, currentAttributes, attributes) =>
      break
    } else if (right.deleted) {
      // continue
-    } else if (right.content.constructor === ContentFormat && (attributes[(/** @type {ContentFormat} */ (right.content)).key] || null) === /** @type {ContentFormat} */ (right.content).value) {
+    } else if (right.content.constructor === ContentFormat && equalAttrs(attributes[(/** @type {ContentFormat} */ (right.content)).key] || null, /** @type {ContentFormat} */ (right.content).value)) {
      // found a format, update currentAttributes and continue
      updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (right.content))
    } else {
@@ -207,10 +213,10 @@ const minimizeAttributeChanges = (left, right, currentAttributes, attributes) =>
 const insertAttributes = (transaction, parent, left, right, currentAttributes, attributes) => {
  const negatedAttributes = new Map()
  // insert format-start items
-  for (let key in attributes) {
+  for (const key in attributes) {
    const val = attributes[key]
    const currentVal = currentAttributes.get(key) || null
-    if (currentVal !== val) {
+    if (!equalAttrs(currentVal, val)) {
      // save negated attribute (set null if currentVal undefined)
      negatedAttributes.set(key, currentVal)
      left = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, new ContentFormat(key, val))
@@ -226,7 +232,7 @@ const insertAttributes = (transaction, parent, left, right, currentAttributes, a
 * @param {Item|null} left
 * @param {Item|null} right
 * @param {Map<string,any>} currentAttributes
- * @param {string} text
+ * @param {string|object} text
 * @param {Object<string,any>} attributes
 * @return {ItemListPosition}
 *
@@ -234,7 +240,7 @@ const insertAttributes = (transaction, parent, left, right, currentAttributes, a
 * @function
 **/
 const insertText = (transaction, parent, left, right, currentAttributes, text, attributes) => {
-  for (let [key] of currentAttributes) {
+  for (const [key] of currentAttributes) {
    if (attributes[key] === undefined) {
      attributes[key] = null
    }
@@ -272,13 +278,13 @@ const formatText = (transaction, parent, left, right, currentAttributes, length,
  // iterate until first non-format or null is found
  // delete all formats with attributes[format.key] != null
  while (length > 0 && right !== null) {
-    if (right.deleted === false) {
+    if (!right.deleted) {
      switch (right.content.constructor) {
-        case ContentFormat:
+        case ContentFormat: {
          const { key, value } = /** @type {ContentFormat} */ (right.content)
          const attr = attributes[key]
          if (attr !== undefined) {
-            if (attr === value) {
+            if (equalAttrs(attr, value)) {
              negatedAttributes.delete(key)
            } else {
              negatedAttributes.set(key, value)
@@ -287,10 +293,11 @@ const formatText = (transaction, parent, left, right, currentAttributes, length,
          }
          updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (right.content))
          break
+        }
        case ContentEmbed:
        case ContentString:
          if (length < right.length) {
-            getItemCleanStart(transaction, transaction.doc.store, createID(right.id.client, right.id.clock + length))
+            getItemCleanStart(transaction, createID(right.id.client, right.id.clock + length))
          }
          length -= right.length
          break
@@ -299,6 +306,17 @@ const formatText = (transaction, parent, left, right, currentAttributes, length,
    left = right
    right = right.right
  }
+  // Quill just assumes that the editor starts with a newline and that it always
+  // ends with a newline. We only insert that newline when a new newline is
+  // inserted - i.e when length is bigger than type.length
+  if (length > 0) {
+    let newlines = ''
+    for (; length > 0; length--) {
+      newlines += '\n'
+    }
+    left = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, new ContentString(newlines))
+    left.integrate(transaction)
+  }
  return insertNegatedAttributes(transaction, parent, left, right, negatedAttributes)
 }

@@ -323,7 +341,7 @@ const deleteText = (transaction, left, right, currentAttributes, length) => {
        case ContentEmbed:
        case ContentString:
          if (length < right.length) {
-            getItemCleanStart(transaction, transaction.doc.store, createID(right.id.client, right.id.clock + length))
+            getItemCleanStart(transaction, createID(right.id.client, right.id.clock + length))
          }
          length -= right.length
          right.delete(transaction)
@@ -387,6 +405,7 @@ export class YTextEvent extends YEvent {
     */
    this._delta = null
  }
+
  /**
   * Compute the changes in the delta format.
   * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
@@ -411,7 +430,10 @@ export class YTextEvent extends YEvent {
        /**
         * @type {Object<string,any>}
         */
-        let attributes = {} // counts added or removed new attributes for retain
+        const attributes = {} // counts added or removed new attributes for retain
+        /**
+         * @type {string|object}
+         */
        let insert = ''
        let retain = 0
        let deleteLen = 0
@@ -430,7 +452,7 @@ export class YTextEvent extends YEvent {
                op = { insert }
                if (currentAttributes.size > 0) {
                  op.attributes = {}
-                  for (let [key, value] of currentAttributes) {
+                  for (const [key, value] of currentAttributes) {
                    if (value !== null) {
                      op.attributes[key] = value
                    }
@@ -442,7 +464,7 @@ export class YTextEvent extends YEvent {
                op = { retain }
                if (Object.keys(attributes).length > 0) {
                  op.attributes = {}
-                  for (let key in attributes) {
+                  for (const key in attributes) {
                    op.attributes[key] = attributes[key]
                  }
                }
@@ -500,16 +522,16 @@ export class YTextEvent extends YEvent {
                retain += item.length
              }
              break
-            case ContentFormat:
+            case ContentFormat: {
              const { key, value } = /** @type {ContentFormat} */ (item.content)
              if (this.adds(item)) {
                if (!this.deletes(item)) {
                  const curVal = currentAttributes.get(key) || null
-                  if (curVal !== value) {
+                  if (!equalAttrs(curVal, value)) {
                    if (action === 'retain') {
                      addOp()
                    }
-                    if (value === (oldAttributes.get(key) || null)) {
+                    if (equalAttrs(value, (oldAttributes.get(key) || null))) {
                      delete attributes[key]
                    } else {
                      attributes[key] = value
@@ -521,7 +543,7 @@ export class YTextEvent extends YEvent {
              } else if (this.deletes(item)) {
                oldAttributes.set(key, value)
                const curVal = currentAttributes.get(key) || null
-                if (curVal !== value) {
+                if (!equalAttrs(curVal, value)) {
                  if (action === 'retain') {
                    addOp()
                  }
@@ -531,7 +553,7 @@ export class YTextEvent extends YEvent {
                oldAttributes.set(key, value)
                const attr = attributes[key]
                if (attr !== undefined) {
-                  if (attr !== value) {
+                  if (!equalAttrs(attr, value)) {
                    if (action === 'retain') {
                      addOp()
                    }
@@ -552,12 +574,13 @@ export class YTextEvent extends YEvent {
                updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (item.content))
              }
              break
+            }
          }
          item = item.right
        }
        addOp()
        while (delta.length > 0) {
-          let lastOp = delta[delta.length - 1]
+          const lastOp = delta[delta.length - 1]
          if (lastOp.retain !== undefined && lastOp.attributes === undefined) {
            // retain delta's if they don't assign attributes
            delta.pop()
@@ -594,6 +617,11 @@ export class YText extends AbstractType {
    this._pending = string !== undefined ? [() => this.insert(0, string)] : []
  }

+  /**
+   * Number of characters of this text type.
+   *
+   * @type {number}
+   */
  get length () {
    return this._length
  }
@@ -614,6 +642,10 @@ export class YText extends AbstractType {
    this._pending = null
  }

+  _copy () {
+    return new YText()
+  }
+
  /**
   * Creates YTextEvent and calls observers.
   *
@@ -646,6 +678,16 @@ export class YText extends AbstractType {
    return str
  }

+  /**
+   * Returns the unformatted string representation of this YText type.
+   *
+   * @return {string}
+   * @public
+   */
+  toJSON () {
+    return this.toString()
+  }
+
  /**
   * Apply a {@link Delta} on this shared YText type.
   *
@@ -664,7 +706,15 @@ export class YText extends AbstractType {
        for (let i = 0; i < delta.length; i++) {
          const op = delta[i]
          if (op.insert !== undefined) {
-            pos = insertText(transaction, this, pos.left, pos.right, currentAttributes, op.insert, op.attributes || {})
+            // Quill assumes that the content starts with an empty paragraph.
+            // Yjs/Y.Text assumes that it starts empty. We always hide that
+            // there is a newline at the end of the content.
+            // If we omit this step, clients will see a different number of
+            // paragraphs, but nothing bad will happen.
+            const ins = (typeof op.insert === 'string' && i === delta.length - 1 && pos.right === null && op.insert.slice(-1) === '\n') ? op.insert.slice(0, -1) : op.insert
+            if (typeof ins !== 'string' || ins.length > 0) {
+              pos = insertText(transaction, this, pos.left, pos.right, currentAttributes, ins, op.attributes || {})
+            }
          } else if (op.retain !== undefined) {
            pos = formatText(transaction, this, pos.left, pos.right, currentAttributes, op.retain, op.attributes || {})
          } else if (op.delete !== undefined) {
@@ -682,16 +732,18 @@ export class YText extends AbstractType {
   *
   * @param {Snapshot} [snapshot]
   * @param {Snapshot} [prevSnapshot]
+   * @param {function('removed' | 'added', ID):any} [computeYChange]
   * @return {any} The Delta representation of this type.
   *
   * @public
   */
-  toDelta (snapshot, prevSnapshot) {
+  toDelta (snapshot, prevSnapshot, computeYChange) {
    /**
     * @type{Array<any>}
     */
    const ops = []
    const currentAttributes = new Map()
+    const doc = /** @type {Doc} */ (this.doc)
    let str = ''
    let n = this._start
    function packStr () {
@@ -702,7 +754,7 @@ export class YText extends AbstractType {
         */
        const attributes = {}
        let addAttributes = false
-        for (let [key, value] of currentAttributes) {
+        for (const [key, value] of currentAttributes) {
          addAttributes = true
          attributes[key] = value
        }
@@ -717,42 +769,55 @@ export class YText extends AbstractType {
        str = ''
      }
    }
-    while (n !== null) {
-      if (isVisible(n, snapshot) || (prevSnapshot !== undefined && isVisible(n, prevSnapshot))) {
-        switch (n.content.constructor) {
-          case ContentString:
-            const cur = currentAttributes.get('ychange')
-            if (snapshot !== undefined && !isVisible(n, snapshot)) {
-              if (cur === undefined || cur.user !== n.id.client || cur.state !== 'removed') {
-                packStr()
-                currentAttributes.set('ychange', { user: n.id.client, state: 'removed' })
-              }
-            } else if (prevSnapshot !== undefined && !isVisible(n, prevSnapshot)) {
-              if (cur === undefined || cur.user !== n.id.client || cur.state !== 'added') {
-                packStr()
-                currentAttributes.set('ychange', { user: n.id.client, state: 'added' })
-              }
-            } else if (cur !== undefined) {
-              packStr()
-              currentAttributes.delete('ychange')
-            }
-            str += /** @type {ContentString} */ (n.content).str
-            break
-          case ContentEmbed:
-            packStr()
-            ops.push({
-              insert: /** @type {ContentEmbed} */ (n.content).embed
-            })
-            break
-          case ContentFormat:
-            packStr()
-            updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (n.content))
-            break
-        }
+    // snapshots are merged again after the transaction, so we need to keep the
+    // transalive until we are done
+    transact(doc, transaction => {
+      if (snapshot) {
+        splitSnapshotAffectedStructs(transaction, snapshot)
      }
-      n = n.right
-    }
-    packStr()
+      if (prevSnapshot) {
+        splitSnapshotAffectedStructs(transaction, prevSnapshot)
+      }
+      while (n !== null) {
+        if (isVisible(n, snapshot) || (prevSnapshot !== undefined && isVisible(n, prevSnapshot))) {
+          switch (n.content.constructor) {
+            case ContentString: {
+              const cur = currentAttributes.get('ychange')
+              if (snapshot !== undefined && !isVisible(n, snapshot)) {
+                if (cur === undefined || cur.user !== n.id.client || cur.state !== 'removed') {
+                  packStr()
+                  currentAttributes.set('ychange', computeYChange ? computeYChange('removed', n.id) : { type: 'removed' })
+                }
+              } else if (prevSnapshot !== undefined && !isVisible(n, prevSnapshot)) {
+                if (cur === undefined || cur.user !== n.id.client || cur.state !== 'added') {
+                  packStr()
+                  currentAttributes.set('ychange', computeYChange ? computeYChange('added', n.id) : { type: 'added' })
+                }
+              } else if (cur !== undefined) {
+                packStr()
+                currentAttributes.delete('ychange')
+              }
+              str += /** @type {ContentString} */ (n.content).str
+              break
+            }
+            case ContentEmbed:
+              packStr()
+              ops.push({
+                insert: /** @type {ContentEmbed} */ (n.content).embed
+              })
+              break
+            case ContentFormat:
+              if (isVisible(n, snapshot)) {
+                packStr()
+                updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (n.content))
+              }
+              break
+          }
+        }
+        n = n.right
+      }
+      packStr()
+    }, splitSnapshotAffectedStructs)
    return ops
  }

@@ -761,19 +826,24 @@ export class YText extends AbstractType {
   *
   * @param {number} index The index at which to start inserting.
   * @param {String} text The text to insert at the specified position.
-   * @param {TextAttributes} attributes Optionally define some formatting
+   * @param {TextAttributes} [attributes] Optionally define some formatting
   *                                    information to apply on the inserted
   *                                    Text.
   * @public
   */
-  insert (index, text, attributes = {}) {
+  insert (index, text, attributes) {
    if (text.length <= 0) {
      return
    }
    const y = this.doc
    if (y !== null) {
      transact(y, transaction => {
-        const { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        const { left, right, currentAttributes } = findPosition(transaction, this, index)
+        if (!attributes) {
+          attributes = {}
+          // @ts-ignore
+          currentAttributes.forEach((v, k) => { attributes[k] = v })
+        }
        insertText(transaction, this, left, right, currentAttributes, text, attributes)
      })
    } else {
@@ -798,7 +868,7 @@ export class YText extends AbstractType {
    const y = this.doc
    if (y !== null) {
      transact(y, transaction => {
-        const { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        const { left, right, currentAttributes } = findPosition(transaction, this, index)
        insertText(transaction, this, left, right, currentAttributes, embed, attributes)
      })
    } else {
@@ -821,7 +891,7 @@ export class YText extends AbstractType {
    const y = this.doc
    if (y !== null) {
      transact(y, transaction => {
-        const { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        const { left, right, currentAttributes } = findPosition(transaction, this, index)
        deleteText(transaction, left, right, currentAttributes, length)
      })
    } else {
@@ -843,7 +913,7 @@ export class YText extends AbstractType {
    const y = this.doc
    if (y !== null) {
      transact(y, transaction => {
-        let { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        const { left, right, currentAttributes } = findPosition(transaction, this, index)
        if (right === null) {
          return
        }
--- a/src/types/YXmlElement.js
+++ b/src/types/YXmlElement.js
@@ -24,7 +24,7 @@ import * as decoding from 'lib0/decoding.js'
 export class YXmlElement extends YXmlFragment {
  constructor (nodeName = 'UNDEFINED') {
    super()
-    this.nodeName = nodeName.toUpperCase()
+    this.nodeName = nodeName
    /**
     * @type {Map<string, any>|null}
     * @private
@@ -45,12 +45,10 @@ export class YXmlElement extends YXmlFragment {
   */
  _integrate (y, item) {
    super._integrate(y, item)
-    this.insert(0, /** @type {Array} */ (this._prelimContent))
-    this._prelimContent = null
    ;(/** @type {Map<string, any>} */ (this._prelimAttrs)).forEach((value, key) => {
      this.setAttribute(key, value)
    })
-    this._prelimContent = null
+    this._prelimAttrs = null
  }

  /**
@@ -76,7 +74,7 @@ export class YXmlElement extends YXmlFragment {
    const attrs = this.getAttributes()
    const stringBuilder = []
    const keys = []
-    for (let key in attrs) {
+    for (const key in attrs) {
      keys.push(key)
    }
    keys.sort()
@@ -142,7 +140,7 @@ export class YXmlElement extends YXmlFragment {
   * Returns all attribute name/value pairs in a JSON Object.
   *
   * @param {Snapshot} [snapshot]
-   * @return {Object} A JSON Object that describes the attributes.
+   * @return {Object<string, any>} A JSON Object that describes the attributes.
   *
   * @public
   */
@@ -167,8 +165,8 @@ export class YXmlElement extends YXmlFragment {
   */
  toDOM (_document = document, hooks = {}, binding) {
    const dom = _document.createElement(this.nodeName)
-    let attrs = this.getAttributes()
-    for (let key in attrs) {
+    const attrs = this.getAttributes()
+    for (const key in attrs) {
      dom.setAttribute(key, attrs[key])
    }
    typeListForEach(this, yxml => {
--- a/src/types/YXmlFragment.js
+++ b/src/types/YXmlFragment.js
@@ -14,7 +14,7 @@ import {
  YXmlFragmentRefID,
  callTypeObservers,
  transact,
-  ContentType, Transaction, Item, YXmlText, YXmlHook, Snapshot // eslint-disable-line
+  Doc, ContentType, Transaction, Item, YXmlText, YXmlHook, Snapshot // eslint-disable-line
 } from '../internals.js'

 import * as encoding from 'lib0/encoding.js'
@@ -68,6 +68,7 @@ export class YXmlTreeWalker {
  [Symbol.iterator] () {
    return this
  }
+
  /**
   * Get the next node.
   *
@@ -130,6 +131,32 @@ export class YXmlFragment extends AbstractType {
     */
    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
+   * @private
+   */
+  _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.
   *
@@ -169,7 +196,7 @@ export class YXmlFragment extends AbstractType {
  querySelector (query) {
    query = query.toUpperCase()
    // @ts-ignore
-    const iterator = new YXmlTreeWalker(this, element => element.nodeName === query)
+    const iterator = new YXmlTreeWalker(this, element => element.nodeName && element.nodeName.toUpperCase() === query)
    const next = iterator.next()
    if (next.done) {
      return null
@@ -192,7 +219,7 @@ export class YXmlFragment extends AbstractType {
  querySelectorAll (query) {
    query = query.toUpperCase()
    // @ts-ignore
-    return Array.from(new YXmlTreeWalker(this, element => element.nodeName === query))
+    return Array.from(new YXmlTreeWalker(this, element => element.nodeName && element.nodeName.toUpperCase() === query))
  }

  /**
@@ -215,6 +242,9 @@ export class YXmlFragment extends AbstractType {
    return typeListMap(this, xml => xml.toString()).join('')
  }

+  /**
+   * @return {string}
+   */
  toJSON () {
    return this.toString()
  }
@@ -282,6 +312,7 @@ export class YXmlFragment extends AbstractType {
      this._prelimContent.splice(index, length)
    }
  }
+
  /**
   * Transforms this YArray to a JavaScript Array.
   *
@@ -290,6 +321,7 @@ export class YXmlFragment extends AbstractType {
  toArray () {
    return typeListToArray(this)
  }
+
  /**
   * Transform the properties of this type to binary and write it to an
   * BinaryEncoder.
--- a/src/types/YXmlText.js
+++ b/src/types/YXmlText.js
@@ -9,6 +9,10 @@ import * as decoding from 'lib0/decoding.js' // eslint-disable-line
 * simple formatting information like bold and italic.
 */
 export class YXmlText extends YText {
+  _copy () {
+    return new YXmlText()
+  }
+
  /**
   * Creates a Dom Element that mirrors this YXmlText.
   *
@@ -36,9 +40,9 @@ export class YXmlText extends YText {
    // @ts-ignore
    return this.toDelta().map(delta => {
      const nestedNodes = []
-      for (let nodeName in delta.attributes) {
+      for (const nodeName in delta.attributes) {
        const attrs = []
-        for (let key in delta.attributes[nodeName]) {
+        for (const key in delta.attributes[nodeName]) {
          attrs.push({ key, value: delta.attributes[nodeName][key] })
        }
        // sort attributes to get a unique order
@@ -53,7 +57,7 @@ export class YXmlText extends YText {
        const node = nestedNodes[i]
        str += `<${node.nodeName}`
        for (let j = 0; j < node.attrs.length; j++) {
-          const attr = node.attrs[i]
+          const attr = node.attrs[j]
          str += ` ${attr.key}="${attr.value}"`
        }
        str += '>'
@@ -66,6 +70,9 @@ export class YXmlText extends YText {
    }).join('')
  }

+  /**
+   * @return {string}
+   */
  toJSON () {
    return this.toString()
  }
--- a/src/utils/DeleteSet.js
+++ b/src/utils/DeleteSet.js
@@ -4,9 +4,11 @@ import {
  createID,
  getState,
  splitItem,
-  Item, AbstractStruct, StructStore, Transaction, ID // eslint-disable-line
+  iterateStructs,
+  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'
@@ -47,29 +49,20 @@ export class DeleteSet {
 }

 /**
- * Iterate over all structs that were deleted.
- *
- * This function expects that the deletes structs are not merged. Hence, you can
- * probably only use it in type observes and `afterTransaction` events. But not
- * in `afterTransactionCleanup`.
+ * Iterate over all structs that the DeleteSet gc's.
 *
+ * @param {Transaction} transaction
 * @param {DeleteSet} ds
- * @param {StructStore} store
- * @param {function(AbstractStruct):void} f
+ * @param {function(GC|Item):void} f
 *
 * @function
 */
-export const iterateDeletedStructs = (ds, store, f) =>
+export const iterateDeletedStructs = (transaction, ds, f) =>
  ds.clients.forEach((deletes, clientid) => {
-    const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(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]
-      let index = findIndexSS(structs, del.clock)
-      let struct
-      do {
-        struct = structs[index++]
-        f(struct)
-      } while (index < structs.length && structs[index].id.clock < del.clock + del.len)
+      iterateStructs(transaction, structs, del.clock, del.len, f)
    }
  })

@@ -143,6 +136,32 @@ export const sortAndMergeDeleteSet = ds => {
  })
 }

+/**
+ * @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 {ID} id
@@ -155,6 +174,8 @@ export const addToDeleteSet = (ds, id, length) => {
  map.setIfUndefined(ds.clients, id.client, () => []).push(new DeleteItem(id.clock, length))
 }

+export const createDeleteSet = () => new DeleteSet()
+
 /**
 * @param {StructStore} ss
 * @return {DeleteSet} Merged and sorted DeleteSet
@@ -163,7 +184,7 @@ export const addToDeleteSet = (ds, id, length) => {
 * @function
 */
 export const createDeleteSetFromStructStore = ss => {
-  const ds = new DeleteSet()
+  const ds = createDeleteSet()
  ss.clients.forEach((structs, client) => {
    /**
     * @type {Array<DeleteItem>}
@@ -210,6 +231,26 @@ export const writeDeleteSet = (encoder, ds) => {
  })
 }

+/**
+ * @param {decoding.Decoder} decoder
+ * @return {DeleteSet}
+ *
+ * @private
+ * @function
+ */
+export const readDeleteSet = decoder => {
+  const ds = new DeleteSet()
+  const numClients = decoding.readVarUint(decoder)
+  for (let i = 0; i < numClients; i++) {
+    const client = decoding.readVarUint(decoder)
+    const numberOfDeletes = decoding.readVarUint(decoder)
+    for (let i = 0; i < numberOfDeletes; i++) {
+      addToDeleteSet(ds, createID(client, decoding.readVarUint(decoder)), decoding.readVarUint(decoder))
+    }
+  }
+  return ds
+}
+
 /**
 * @param {decoding.Decoder} decoder
 * @param {Transaction} transaction
@@ -218,7 +259,7 @@ export const writeDeleteSet = (encoder, ds) => {
 * @private
 * @function
 */
-export const readDeleteSet = (decoder, transaction, store) => {
+export const readAndApplyDeleteSet = (decoder, transaction, store) => {
  const unappliedDS = new DeleteSet()
  const numClients = decoding.readVarUint(decoder)
  for (let i = 0; i < numClients; i++) {
@@ -265,6 +306,7 @@ export const readDeleteSet = (decoder, transaction, store) => {
    }
  }
  if (unappliedDS.clients.size > 0) {
+    // TODO: no need for encoding+decoding ds anymore
    const unappliedDSEncoder = encoding.createEncoder()
    writeDeleteSet(unappliedDSEncoder, unappliedDS)
    store.pendingDeleteReaders.push(decoding.createDecoder(encoding.toUint8Array(unappliedDSEncoder)))
--- a/src/utils/Doc.js
+++ b/src/utils/Doc.js
@@ -23,10 +23,14 @@ import * as map from 'lib0/map.js'
 */
 export class Doc extends Observable {
  /**
-   * @param {Object|undefined} conf configuration
+   * @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 (conf = {}) {
+  constructor ({ gc = true, gcFilter = () => true } = {}) {
    super()
+    this.gc = gc
+    this.gcFilter = gcFilter
    this.clientID = random.uint32()
    /**
     * @type {Map<string, AbstractType<YEvent>>}
@@ -44,6 +48,7 @@ export class Doc extends Observable {
     */
    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
@@ -58,6 +63,7 @@ export class Doc extends Observable {
  transact (f, origin = null) {
    transact(this, f, origin)
  }
+
  /**
   * Define a shared data type.
   *
@@ -116,6 +122,7 @@ export class Doc extends Observable {
    }
    return type
  }
+
  /**
   * @template T
   * @param {string} name
@@ -127,6 +134,7 @@ export class Doc extends Observable {
    // @ts-ignore
    return this.get(name, YArray)
  }
+
  /**
   * @param {string} name
   * @return {YText}
@@ -137,6 +145,7 @@ export class Doc extends Observable {
    // @ts-ignore
    return this.get(name, YText)
  }
+
  /**
   * @param {string} name
   * @return {YMap<any>}
@@ -147,6 +156,7 @@ export class Doc extends Observable {
    // @ts-ignore
    return this.get(name, YMap)
  }
+
  /**
   * @param {string} name
   * @return {YXmlFragment}
@@ -157,6 +167,7 @@ export class Doc extends Observable {
    // @ts-ignore
    return this.get(name, YXmlFragment)
  }
+
  /**
   * Emit `destroy` event and unregister all event handlers.
   *
@@ -166,6 +177,7 @@ export class Doc extends Observable {
    this.emit('destroyed', [true])
    super.destroy()
  }
+
  /**
   * @param {string} eventName
   * @param {function} f
@@ -173,6 +185,7 @@ export class Doc extends Observable {
  on (eventName, f) {
    super.on(eventName, f)
  }
+
  /**
   * @param {string} eventName
   * @param {function} f
--- a/src/utils/ID.js
+++ b/src/utils/ID.js
@@ -81,7 +81,7 @@ export const readID = decoder =>
 */
 export const findRootTypeKey = type => {
  // @ts-ignore _y must be defined, otherwise unexpected case
-  for (let [key, value] of type.doc.share) {
+  for (const [key, value] of type.doc.share) {
    if (value === type) {
      return key
    }
--- a/src/utils/PermanentUserData.js
+++ b/src/utils/PermanentUserData.js
@@ -0,0 +1,142 @@
+
+import {
+  YArray,
+  YMap,
+  readDeleteSet,
+  writeDeleteSet,
+  createDeleteSet,
+  ID, DeleteSet, YArrayEvent, Transaction, Doc // eslint-disable-line
+} from '../internals.js'
+
+import * as decoding from 'lib0/decoding.js'
+import * as encoding from 'lib0/encoding.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(decoding.createDecoder(encodedDs))]))
+            }
+          })
+        })
+      })
+      this.dss.set(userDescription, mergeDeleteSets(ds.map(encodedDs => readDeleteSet(decoding.createDecoder(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 = encoding.createEncoder()
+          const ds = this.dss.get(userDescription)
+          if (ds) {
+            writeDeleteSet(encoder, ds)
+            user.get('ds').push([encoding.toUint8Array(encoder)])
+          }
+        }
+      }, 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 = encoding.createEncoder()
+          writeDeleteSet(encoder, ds)
+          yds.push([encoding.toUint8Array(encoder)])
+        }
+      })
+    })
+  }
+
+  /**
+   * @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) {
+      if (isDeleted(ds, id)) {
+        return userDescription
+      }
+    }
+    return null
+  }
+}
--- a/src/utils/RelativePosition.js
+++ b/src/utils/RelativePosition.js
@@ -1,6 +1,5 @@

 import {
-  getItem,
  createID,
  writeID,
  readID,
@@ -9,6 +8,7 @@ import {
  findRootTypeKey,
  Item,
  ContentType,
+  followRedone,
  ID, Doc, AbstractType // eslint-disable-line
 } from '../internals.js'

@@ -63,7 +63,7 @@ export class RelativePosition {
 }

 /**
- * @param {Object} json
+ * @param {any} json
 * @return {RelativePosition}
 *
 * @function
@@ -222,19 +222,22 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
    if (getState(store, rightID.client) <= rightID.clock) {
      return null
    }
-    const right = getItem(store, rightID)
+    const res = followRedone(store, rightID)
+    const right = res.item
    if (!(right instanceof Item)) {
      return null
    }
-    index = right.deleted || !right.countable ? 0 : rightID.clock - right.id.clock
-    let n = right.left
-    while (n !== null) {
-      if (!n.deleted && n.countable) {
-        index += n.length
-      }
-      n = n.left
-    }
    type = right.parent
+    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)
@@ -243,9 +246,9 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
        // type does not exist yet
        return null
      }
-      const struct = getItem(store, typeID)
-      if (struct instanceof Item && struct.content instanceof ContentType) {
-        type = struct.content.type
+      const { item } = followRedone(store, typeID)
+      if (item instanceof Item && item.content instanceof ContentType) {
+        type = item.content.type
      } else {
        // struct is garbage collected
        return null
@@ -255,9 +258,6 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
    }
    index = type._length
  }
-  if (type._item !== null && type._item.deleted) {
-    return null
-  }
  return createAbsolutePosition(type, index)
 }

--- a/src/utils/Snapshot.js
+++ b/src/utils/Snapshot.js
@@ -1,15 +1,31 @@

 import {
  isDeleted,
-  DeleteSet, Item // eslint-disable-line
+  createDeleteSetFromStructStore,
+  getStateVector,
+  getItemCleanStart,
+  createID,
+  iterateDeletedStructs,
+  writeDeleteSet,
+  writeStateVector,
+  readDeleteSet,
+  readStateVector,
+  createDeleteSet,
+  getState,
+  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 encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
 export class Snapshot {
  /**
   * @param {DeleteSet} ds
-   * @param {Map<number,number>} sm state map
+   * @param {Map<number,number>} sv state map
   */
-  constructor (ds, sm) {
+  constructor (ds, sv) {
    /**
     * @type {DeleteSet}
     * @private
@@ -20,16 +36,79 @@ export class Snapshot {
     * @type {Map<number,number>}
     * @private
     */
-    this.sm = sm
+    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) {
+    if (sv2.get(key) !== value) {
+      return false
+    }
+  }
+  for (const [client, dsitems1] of ds1) {
+    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
+ * @return {Uint8Array}
+ */
+export const encodeSnapshot = snapshot => {
+  const encoder = encoding.createEncoder()
+  writeDeleteSet(encoder, snapshot.ds)
+  writeStateVector(encoder, snapshot.sv)
+  return encoding.toUint8Array(encoder)
+}
+
+/**
+ * @param {Uint8Array} buf
+ * @return {Snapshot}
+ */
+export const decodeSnapshot = buf => {
+  const decoder = decoding.createDecoder(buf)
+  return new Snapshot(readDeleteSet(decoder), readStateVector(decoder))
+}
+
 /**
 * @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
@@ -38,5 +117,24 @@ export const createSnapshot = (ds, sm) => new Snapshot(ds, sm)
 * @function
 */
 export const isVisible = (item, snapshot) => snapshot === undefined ? !item.deleted : (
-  snapshot.sm.has(item.id.client) && (snapshot.sm.get(item.id.client) || 0) > item.id.clock && !isDeleted(snapshot.ds, item.id)
+  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
@@ -2,7 +2,7 @@
 import {
  GC,
  splitItem,
-  GCRef, ItemRef, Transaction, ID, Item, AbstractStruct // eslint-disable-line
+  GCRef, ItemRef, Transaction, ID, Item // eslint-disable-line
 } from '../internals.js'

 import * as math from 'lib0/math.js'
@@ -12,7 +12,7 @@ import * as decoding from 'lib0/decoding.js' // eslint-disable-line
 export class StructStore {
  constructor () {
    /**
-     * @type {Map<number,Array<AbstractStruct>>}
+     * @type {Map<number,Array<GC|Item>>}
     * @private
     */
    this.clients = new Map()
@@ -97,7 +97,7 @@ export const integretyCheck = store => {

 /**
 * @param {StructStore} store
- * @param {AbstractStruct} struct
+ * @param {GC|Item} struct
 *
 * @private
 * @function
@@ -151,14 +151,14 @@ export const findIndexSS = (structs, clock) => {
 *
 * @param {StructStore} store
 * @param {ID} id
- * @return {AbstractStruct}
+ * @return {GC|Item}
 *
 * @private
 * @function
 */
 export const find = (store, id) => {
  /**
-   * @type {Array<AbstractStruct>}
+   * @type {Array<GC|Item>}
   */
  // @ts-ignore
  const structs = store.clients.get(id.client)
@@ -178,26 +178,34 @@ export const find = (store, id) => {
 // @ts-ignore
 export const getItem = (store, id) => find(store, id)

+/**
+ * @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 {StructStore} store
 * @param {ID} id
 * @return {Item}
 *
 * @private
 * @function
 */
-export const getItemCleanStart = (transaction, store, id) => {
-  const structs = /** @type {Array<Item>} */ (store.clients.get(id.client))
-  const index = findIndexSS(structs, id.clock)
-  let struct = structs[index]
-  if (struct.id.clock < id.clock && struct.constructor !== GC) {
-    struct = splitItem(transaction, struct, id.clock - struct.id.clock)
-    structs.splice(index + 1, 0, struct)
-  }
-  return struct
+export const getItemCleanStart = (transaction, id) => {
+  const structs = /** @type {Array<Item>} */ (transaction.doc.store.clients.get(id.client))
+  return structs[findIndexCleanStart(transaction, structs, id.clock)]
 }

 /**
@@ -228,13 +236,40 @@ export const getItemCleanEnd = (transaction, store, id) => {
 /**
 * Replace `item` with `newitem` in store
 * @param {StructStore} store
- * @param {AbstractStruct} struct
- * @param {AbstractStruct} newStruct
+ * @param {GC|Item} struct
+ * @param {GC|Item} newStruct
 *
 * @private
 * @function
 */
 export const replaceStruct = (store, struct, newStruct) => {
-  const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(struct.id.client))
+  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
@@ -10,12 +10,14 @@ import {
  findIndexSS,
  callEventHandlerListeners,
  Item,
-  ID, AbstractType, AbstractStruct, YEvent, Doc // eslint-disable-line
+  StructStore, ID, AbstractType, AbstractStruct, YEvent, Doc // eslint-disable-line
 } from '../internals.js'

 import * as encoding from 'lib0/encoding.js'
 import * as map from 'lib0/map.js'
 import * as math from 'lib0/math.js'
+import * as set from 'lib0/set.js'
+import { callAll } from 'lib0/function.js'

 /**
 * A transaction is created for every change on the Yjs model. It is possible
@@ -45,8 +47,9 @@ export class Transaction {
  /**
   * @param {Doc} doc
   * @param {any} origin
+   * @param {boolean} local
   */
-  constructor (doc, origin) {
+  constructor (doc, origin, local) {
    /**
     * The Yjs instance.
     * @type {Doc}
@@ -70,7 +73,7 @@ export class Transaction {
    /**
     * 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)
+     * Maps from type to parentSubs (`item.parentSub = null` for YArray)
     * @type {Map<AbstractType<YEvent>,Set<String|null>>}
     */
    this.changed = new Map()
@@ -89,6 +92,16 @@ export class Transaction {
     * @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
  }
 }

@@ -117,22 +130,223 @@ export const nextID = transaction => {
  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 && right.parent._map.get(right.parentSub) === right) {
+        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) {
+    const structs = /** @type {Array<AbstractStruct>} */ (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
+  for (const [client, deleteItems] of ds.clients) {
+    const structs = /** @type {Array<AbstractStruct>} */ (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
+    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
+      for (const [client, clock] of transaction.afterState) {
+        const beforeClock = transaction.beforeState.get(client) || 0
+        if (beforeClock !== clock) {
+          const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
+          // we iterate from right to left so we can safely remove entries
+          const firstChangePos = math.max(findIndexSS(structs, beforeClock), 1)
+          for (let i = structs.length - 1; i >= firstChangePos; i--) {
+            tryToMergeWithLeft(structs, i)
+          }
+        }
+      }
+      // try to merge mergeStructs
+      // @todo: it makes more sense to transform mergeStructs to a DS, sort it, and merge from right to left
+      //        but at the moment DS does not handle duplicates
+      for (const mid of transaction._mergeStructs) {
+        const client = mid.client
+        const clock = mid.clock
+        const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
+        const replacedStructPos = findIndexSS(structs, clock)
+        if (replacedStructPos + 1 < structs.length) {
+          tryToMergeWithLeft(structs, replacedStructPos + 1)
+        }
+        if (replacedStructPos > 0) {
+          tryToMergeWithLeft(structs, replacedStructPos)
+        }
+      }
+      // @todo Merge all the transactions into one and provide send the data as a single update message
+      doc.emit('afterTransactionCleanup', [transaction, doc])
+      if (doc._observers.has('update')) {
+        const updateMessage = computeUpdateMessageFromTransaction(transaction)
+        if (updateMessage !== null) {
+          doc.emit('update', [encoding.toUint8Array(updateMessage), transaction.origin, doc])
+        }
+      }
+      if (transactionCleanups.length <= i + 1) {
+        doc._transactionCleanups = []
+      } else {
+        cleanupTransactions(transactionCleanups, i + 1)
+      }
+    }
+  }
+}
+
 /**
 * Implements the functionality of `y.transact(()=>{..})`
 *
 * @param {Doc} doc
 * @param {function(Transaction):void} f
- * @param {any} [origin]
+ * @param {any} [origin=true]
 *
 * @private
 * @function
 */
-export const transact = (doc, f, origin = null) => {
+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)
+    doc._transaction = new Transaction(doc, origin, local)
    transactionCleanups.push(doc._transaction)
    doc.emit('beforeTransaction', [doc._transaction, doc])
  }
@@ -142,125 +356,13 @@ export const transact = (doc, f, origin = null) => {
    if (initialCall && transactionCleanups[0] === doc._transaction) {
      // The first transaction ended, now process observer calls.
      // Observer call may create new transactions for which we need to call the observers and do cleanup.
-      // We don't want to nest these calls, so we execute these calls one after another
-      for (let i = 0; i < transactionCleanups.length; i++) {
-        const transaction = transactionCleanups[i]
-        const store = transaction.doc.store
-        const ds = transaction.deleteSet
-        sortAndMergeDeleteSet(ds)
-        transaction.afterState = getStateVector(transaction.doc.store)
-        doc._transaction = null
-        doc.emit('beforeObserverCalls', [transaction, doc])
-        // emit change events on changed types
-        transaction.changed.forEach((subs, itemtype) => {
-          itemtype._callObserver(transaction, subs)
-        })
-        transaction.changedParentTypes.forEach((events, type) => {
-          events = events
-            .filter(event =>
-              event.target._item === null || !event.target._item.deleted
-            )
-          events
-            .forEach(event => {
-              event.currentTarget = type
-            })
-          // we don't need to check for events.length
-          // because we know it has at least one element
-          callEventHandlerListeners(type._dEH, events, transaction)
-        })
-        doc.emit('afterTransaction', [transaction, doc])
-        /**
-         * @param {Array<AbstractStruct>} structs
-         * @param {number} pos
-         */
-        const tryToMergeWithLeft = (structs, pos) => {
-          const left = structs[pos - 1]
-          const right = structs[pos]
-          if (left.deleted === right.deleted && left.constructor === right.constructor) {
-            if (left.mergeWith(right)) {
-              structs.splice(pos, 1)
-              if (right instanceof Item && right.parentSub !== null && right.parent._map.get(right.parentSub) === right) {
-                right.parent._map.set(right.parentSub, /** @type {Item} */ (left))
-              }
-            }
-          }
-        }
-        // replace deleted items with ItemDeleted / GC
-        for (const [client, deleteItems] of ds.clients) {
-          const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
-          for (let di = deleteItems.length - 1; di >= 0; di--) {
-            const deleteItem = deleteItems[di]
-            const endDeleteItemClock = deleteItem.clock + deleteItem.len
-            for (
-              let si = findIndexSS(structs, deleteItem.clock), struct = structs[si];
-              si < structs.length && struct.id.clock < endDeleteItemClock;
-              struct = structs[++si]
-            ) {
-              const struct = structs[si]
-              if (deleteItem.clock + deleteItem.len <= struct.id.clock) {
-                break
-              }
-              if (struct.deleted && struct instanceof Item) {
-                struct.gc(store, false)
-              }
-            }
-          }
-        }
-        // try to merge deleted / gc'd items
-        // merge from right to left for better efficiecy and so we don't miss any merge targets
-        for (const [client, deleteItems] of ds.clients) {
-          const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
-          for (let di = deleteItems.length - 1; di >= 0; di--) {
-            const deleteItem = deleteItems[di]
-            // start with merging the item next to the last deleted item
-            const mostRightIndexToCheck = math.min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1))
-            for (
-              let si = mostRightIndexToCheck, struct = structs[si];
-              si > 0 && struct.id.clock >= deleteItem.clock;
-              struct = structs[--si]
-            ) {
-              tryToMergeWithLeft(structs, si)
-            }
-          }
-        }
-
-        // on all affected store.clients props, try to merge
-        for (const [client, clock] of transaction.afterState) {
-          const beforeClock = transaction.beforeState.get(client) || 0
-          if (beforeClock !== clock) {
-            const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
-            // we iterate from right to left so we can safely remove entries
-            const firstChangePos = math.max(findIndexSS(structs, beforeClock), 1)
-            for (let i = structs.length - 1; i >= firstChangePos; i--) {
-              tryToMergeWithLeft(structs, i)
-            }
-          }
-        }
-        // try to merge mergeStructs
-        // @todo: it makes more sense to transform mergeStructs to a DS, sort it, and merge from right to left
-        //        but at the moment DS does not handle duplicates
-        for (const mid of transaction._mergeStructs) {
-          const client = mid.client
-          const clock = mid.clock
-          const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
-          const replacedStructPos = findIndexSS(structs, clock)
-          if (replacedStructPos + 1 < structs.length) {
-            tryToMergeWithLeft(structs, replacedStructPos + 1)
-          }
-          if (replacedStructPos > 0) {
-            tryToMergeWithLeft(structs, replacedStructPos)
-          }
-        }
-        // @todo Merge all the transactions into one and provide send the data as a single update message
-        doc.emit('afterTransactionCleanup', [transaction, doc])
-        if (doc._observers.has('update')) {
-          const updateMessage = computeUpdateMessageFromTransaction(transaction)
-          if (updateMessage !== null) {
-            doc.emit('update', [encoding.toUint8Array(updateMessage), transaction.origin, doc])
-          }
-        }
-      }
-      doc._transactionCleanups = []
+      // 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,202 +1,283 @@
-// @ts-nocheck
-
 import {
+  mergeDeleteSets,
+  iterateDeletedStructs,
+  keepItem,
+  transact,
+  redoItem,
+  iterateStructs,
  isParentOf,
  createID,
-  transact
+  followRedone,
+  getItemCleanStart,
+  getState,
+  Transaction, Doc, Item, GC, DeleteSet, AbstractType // eslint-disable-line
 } from '../internals.js'

-/**
- * @private
- */
-class ReverseOperation {
-  constructor (y, transaction, bindingInfos) {
-    this.created = new Date()
-    const beforeState = transaction.beforeState
-    if (beforeState.has(y.userID)) {
-      this.toState = createID(y.userID, y.ss.getState(y.userID) - 1)
-      this.fromState = createID(y.userID, beforeState.get(y.userID))
-    } else {
-      this.toState = null
-      this.fromState = null
-    }
-    this.deletedStructs = new Set()
-    transaction.deletedStructs.forEach(struct => {
-      this.deletedStructs.add({
-        from: struct._id,
-        len: struct._length
-      })
-    })
-    /**
-     * Maps from binding to binding information (e.g. cursor information)
-     */
-    this.bindingInfos = bindingInfos
-  }
-}
+import * as time from 'lib0/time.js'
+import { Observable } from 'lib0/observable.js'

-/**
- * @private
- * @function
- */
-function applyReverseOperation (y, scope, reverseBuffer) {
-  let performedUndo = false
-  let undoOp = null
-  transact(y, () => {
-    while (!performedUndo && reverseBuffer.length > 0) {
-      undoOp = reverseBuffer.pop()
-      // make sure that it is possible to iterate {from}-{to}
-      if (undoOp.fromState !== null) {
-        y.os.getItemCleanStart(undoOp.fromState)
-        y.os.getItemCleanEnd(undoOp.toState)
-        y.os.iterate(undoOp.fromState, undoOp.toState, op => {
-          while (op._deleted && op._redone !== null) {
-            op = op._redone
-          }
-          if (op._deleted === false && isParentOf(scope, op)) {
-            performedUndo = true
-            op._delete(y)
-          }
-        })
-      }
-      const redoitems = new Set()
-      for (let del of undoOp.deletedStructs) {
-        const fromState = del.from
-        const toState = createID(fromState.user, fromState.clock + del.len - 1)
-        y.os.getItemCleanStart(fromState)
-        y.os.getItemCleanEnd(toState)
-        y.os.iterate(fromState, toState, op => {
-          if (
-            isParentOf(scope, op) &&
-            op._parent !== y &&
-            (
-              op._id.user !== y.userID ||
-              undoOp.fromState === null ||
-              op._id.clock < undoOp.fromState.clock ||
-              op._id.clock > undoOp.toState.clock
-            )
-          ) {
-            redoitems.add(op)
-          }
-        })
-      }
-      redoitems.forEach(op => {
-        const opUndone = op._redo(y, redoitems)
-        performedUndo = performedUndo || opUndone
-      })
-    }
-  })
-  if (performedUndo && undoOp !== null) {
-    // should be performed after the undo transaction
-    undoOp.bindingInfos.forEach((info, binding) => {
-      binding._restoreUndoStackInfo(info)
-    })
-  }
-  return performedUndo
-}
-
-/**
- * Saves a history of locally applied operations. The UndoManager handles the
- * undoing and redoing of locally created changes.
- *
- * @private
- * @function
- */
-export class UndoManager {
+class StackItem {
  /**
-   * @param {YType} scope The scope on which to listen for changes.
-   * @param {Object} options Optionally provided configuration.
+   * @param {DeleteSet} ds
+   * @param {number} start clock start of the local client
+   * @param {number} len
   */
-  constructor (scope, options = {}) {
-    this.options = options
-    this._bindings = new Set(options.bindings)
-    options.captureTimeout = options.captureTimeout == null ? 500 : options.captureTimeout
-    this._undoBuffer = []
-    this._redoBuffer = []
-    this._scope = scope
-    this._undoing = false
-    this._redoing = false
-    this._lastTransactionWasUndo = false
-    const doc = scope.doc
-    this.y = doc
-    let bindingInfos
-    doc.on('beforeTransaction', (y, transaction, remote) => {
-      if (!remote) {
-        // Store binding information before transaction is executed
-        // By restoring the binding information, we can make sure that the state
-        // before the transaction can be recovered
-        bindingInfos = new Map()
-        this._bindings.forEach(binding => {
-          bindingInfos.set(binding, binding._getUndoStackInfo())
-        })
-      }
-    })
-    doc.on('afterTransaction', (y, transaction, remote) => {
-      if (!remote && transaction.changedParentTypes.has(scope)) {
-        let reverseOperation = new ReverseOperation(y, transaction, bindingInfos)
-        if (!this._undoing) {
-          let lastUndoOp = this._undoBuffer.length > 0 ? this._undoBuffer[this._undoBuffer.length - 1] : null
-          if (
-            this._redoing === false &&
-            this._lastTransactionWasUndo === false &&
-            lastUndoOp !== null &&
-            ((options.captureTimeout < 0) || (reverseOperation.created.getTime() - lastUndoOp.created.getTime()) <= options.captureTimeout)
-          ) {
-            lastUndoOp.created = reverseOperation.created
-            if (reverseOperation.toState !== null) {
-              lastUndoOp.toState = reverseOperation.toState
-              if (lastUndoOp.fromState === null) {
-                lastUndoOp.fromState = reverseOperation.fromState
-              }
-            }
-            reverseOperation.deletedStructs.forEach(lastUndoOp.deletedStructs.add, lastUndoOp.deletedStructs)
-          } else {
-            this._lastTransactionWasUndo = false
-            this._undoBuffer.push(reverseOperation)
-          }
-          if (!this._redoing) {
-            this._redoBuffer = []
-          }
-        } else {
-          this._lastTransactionWasUndo = true
-          this._redoBuffer.push(reverseOperation)
+  constructor (ds, start, len) {
+    this.ds = ds
+    this.start = start
+    this.len = len
+    /**
+     * 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 clientID = doc.clientID
+      const stackItem = /** @type {StackItem} */ (stack.pop())
+      const stackStartClock = stackItem.start
+      const stackEndClock = stackItem.start + stackItem.len
+      const itemsToRedo = new Set()
+      // @todo iterateStructs should not need the structs parameter
+      const structs = /** @type {Array<GC|Item>} */ (store.clients.get(clientID))
+      let performedChange = false
+      if (stackStartClock !== stackEndClock) {
+        // make sure structs don't overlap with the range of created operations [stackItem.start, stackItem.start + stackItem.end)
+        getItemCleanStart(transaction, createID(clientID, stackStartClock))
+        if (stackEndClock < getState(doc.store, clientID)) {
+          getItemCleanStart(transaction, createID(clientID, stackEndClock))
        }
      }
+      iterateDeletedStructs(transaction, stackItem.ds, struct => {
+        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.
+          !(struct.id.client === clientID && struct.id.clock >= stackStartClock && struct.id.clock < stackEndClock)
+        ) {
+          itemsToRedo.add(struct)
+        }
+      })
+      itemsToRedo.forEach(struct => {
+        performedChange = redoItem(transaction, struct, itemsToRedo) !== null || performedChange
+      })
+      /**
+       * @type {Array<Item>}
+       */
+      const itemsToDelete = []
+      iterateStructs(transaction, structs, stackStartClock, stackItem.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 > stackItem.len) {
+              getItemCleanStart(transaction, createID(item.id.client, stackEndClock))
+            }
+            struct = item
+          }
+          if (!struct.deleted && scope.some(type => isParentOf(type, /** @type {Item} */ (struct)))) {
+            itemsToDelete.push(struct)
+          }
+        }
+      })
+      // 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.get(this.doc.clientID) || 0
+      const afterState = transaction.afterState.get(this.doc.clientID) || 0
+      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.len = afterState - lastOp.start
+      } else {
+        // create a new stack op
+        stack.push(new StackItem(transaction.deleteSet, beforeState, afterState - beforeState))
+      }
+      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])
    })
  }

-  /**
-   * Enforce that the next change is created as a separate item in the undo stack
-   *
-   * @private
-   * @function
-   */
-  flushChanges () {
-    this._lastTransactionWasUndo = true
+  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 = []
  }

  /**
-   * Undo the last locally created change.
+   * 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.
   *
-   * @private
-   * @function
+   *
+   * @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
-    const performedUndo = applyReverseOperation(this.y, this._scope, this._undoBuffer)
-    this._undoing = false
-    return performedUndo
+    this.undoing = true
+    let res
+    try {
+      res = popStackItem(this, this.undoStack, 'undo')
+    } finally {
+      this.undoing = false
+    }
+    return res
  }

  /**
-   * Redo the last locally created change.
+   * Redo last undo operation.
   *
-   * @private
-   * @function
+   * @return {StackItem?} Returns StackItem if a change was applied
   */
  redo () {
-    this._redoing = true
-    const performedRedo = applyReverseOperation(this.y, this._scope, this._redoBuffer)
-    this._redoing = false
-    return performedRedo
+    this.redoing = true
+    let res
+    try {
+      res = popStackItem(this, this.redoStack, 'redo')
+    } finally {
+      this.redoing = false
+    }
+    return res
  }
 }
--- a/src/utils/YEvent.js
+++ b/src/utils/YEvent.js
@@ -1,9 +1,12 @@

 import {
  isDeleted,
-  AbstractType, Transaction, AbstractStruct // eslint-disable-line
+  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.
 */
@@ -28,6 +31,10 @@ export class YEvent {
     * @type {Transaction}
     */
    this.transaction = transaction
+    /**
+     * @type {Object|null}
+     */
+    this._changes = null
  }

  /**
@@ -49,6 +56,8 @@ export class YEvent {
  /**
   * 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}
   */
@@ -59,12 +68,121 @@ export class YEvent {
  /**
   * 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)
+  }
 }

 /**
--- a/src/utils/encoding.js
+++ b/src/utils/encoding.js
@@ -23,9 +23,10 @@ import {
  readID,
  getState,
  getStateVector,
-  readDeleteSet,
+  readAndApplyDeleteSet,
  writeDeleteSet,
  createDeleteSetFromStructStore,
+  transact,
  Doc, Transaction, AbstractStruct, StructStore, ID // eslint-disable-line
 } from '../internals.js'

@@ -230,7 +231,7 @@ export const tryResumePendingDeleteReaders = (transaction, store) => {
  const pendingReaders = store.pendingDeleteReaders
  store.pendingDeleteReaders = []
  for (let i = 0; i < pendingReaders.length; i++) {
-    readDeleteSet(pendingReaders[i], transaction, store)
+    readAndApplyDeleteSet(pendingReaders[i], transaction, store)
  }
 }

@@ -299,10 +300,10 @@ export const readStructs = (decoder, transaction, store) => {
 * @function
 */
 export const readUpdate = (decoder, ydoc, transactionOrigin) =>
-  ydoc.transact(transaction => {
+  transact(ydoc, transaction => {
    readStructs(decoder, transaction, ydoc.store)
-    readDeleteSet(decoder, transaction, ydoc.store)
-  }, transactionOrigin)
+    readAndApplyDeleteSet(decoder, transaction, ydoc.store)
+  }, transactionOrigin, false)

 /**
 * Apply a document update created by, for example, `y.on('update', update => ..)` or `update = encodeStateAsUpdate()`.
@@ -381,6 +382,22 @@ export const readStateVector = decoder => {
 */
 export const decodeStateVector = decodedState => readStateVector(decoding.createDecoder(decodedState))

+/**
+ * Write State Vector to `lib0/encoding.js#Encoder`.
+ *
+ * @param {encoding.Encoder} encoder
+ * @param {Map<number,number>} sv
+ * @function
+ */
+export const writeStateVector = (encoder, sv) => {
+  encoding.writeVarUint(encoder, sv.size)
+  sv.forEach((clock, client) => {
+    encoding.writeVarUint(encoder, client)
+    encoding.writeVarUint(encoder, clock)
+  })
+  return encoder
+}
+
 /**
 * Write State Vector to `lib0/encoding.js#Encoder`.
 *
@@ -389,16 +406,7 @@ export const decodeStateVector = decodedState => readStateVector(decoding.create
 *
 * @function
 */
-export const writeDocumentStateVector = (encoder, doc) => {
-  encoding.writeVarUint(encoder, doc.store.clients.size)
-  doc.store.clients.forEach((structs, client) => {
-    const struct = structs[structs.length - 1]
-    const id = struct.id
-    encoding.writeVarUint(encoder, id.client)
-    encoding.writeVarUint(encoder, id.clock + struct.length)
-  })
-  return encoder
-}
+export const writeDocumentStateVector = (encoder, doc) => writeStateVector(encoder, getStateVector(doc.store))

 /**
 * Encode State as Uint8Array.
--- a/src/utils/isParentOf.js
+++ b/src/utils/isParentOf.js
@@ -1,22 +1,22 @@

-import { AbstractType } from '../internals.js' // eslint-disable-line
+import { AbstractType, Item } from '../internals.js' // eslint-disable-line

 /**
 * Check if `parent` is a parent of `child`.
 *
 * @param {AbstractType<any>} parent
- * @param {AbstractType<any>} child
+ * @param {Item|null} child
 * @return {Boolean} Whether `parent` is a parent of `child`.
 *
 * @private
 * @function
 */
 export const isParentOf = (parent, child) => {
-  while (child._item !== null) {
-    if (child === parent) {
+  while (child !== null) {
+    if (child.parent === parent) {
      return true
    }
-    child = child._item.parent
+    child = child.parent._item
  }
  return false
 }
--- a/tests/encoding.tests.js
+++ b/tests/encoding.tests.js
@@ -8,19 +8,21 @@ import {
  readContentJSON,
  readContentEmbed,
  readContentType,
-  readContentFormat
+  readContentFormat,
+  readContentAny
 } from '../src/internals.js'

 /**
 * @param {t.TestCase} tc
 */
 export const testStructReferences = tc => {
-  t.assert(contentRefs.length === 8)
+  t.assert(contentRefs.length === 9)
  t.assert(contentRefs[1] === readContentDeleted)
-  t.assert(contentRefs[2] === readContentJSON)
+  t.assert(contentRefs[2] === readContentJSON) // TODO: deprecate content json?
  t.assert(contentRefs[3] === readContentBinary)
  t.assert(contentRefs[4] === readContentString)
  t.assert(contentRefs[5] === readContentEmbed)
  t.assert(contentRefs[6] === readContentFormat)
  t.assert(contentRefs[7] === readContentType)
+  t.assert(contentRefs[8] === readContentAny)
 }
--- a/tests/index.js
+++ b/tests/index.js
@@ -4,6 +4,7 @@ import * as map from './y-map.tests.js'
 import * as text from './y-text.tests.js'
 import * as xml from './y-xml.tests.js'
 import * as encoding from './encoding.tests.js'
+import * as undoredo from './undo-redo.tests.js'

 import { runTests } from 'lib0/testing.js'
 import { isBrowser, isNode } from 'lib0/environment.js'
@@ -13,7 +14,7 @@ if (isBrowser) {
  log.createVConsole(document.body)
 }
 runTests({
-  map, array, text, xml, encoding
+  map, array, text, xml, encoding, undoredo
 }).then(success => {
  /* istanbul ignore next */
  if (isNode) {
--- a/tests/testHelper.js
+++ b/tests/testHelper.js
@@ -12,6 +12,7 @@ import * as prng from 'lib0/prng.js'
 import * as encoding from 'lib0/encoding.js'
 import * as decoding from 'lib0/decoding.js'
 import * as syncProtocol from 'y-protocols/sync.js'
+import * as object from 'lib0/object.js'
 export * from '../src/internals.js'

 /**
@@ -55,6 +56,7 @@ export class TestYInstance extends Doc {
    })
    this.connect()
  }
+
  /**
   * Disconnect from TestConnector.
   */
@@ -62,6 +64,7 @@ export class TestYInstance extends Doc {
    this.receiving = new Map()
    this.tc.onlineConns.delete(this)
  }
+
  /**
   * Append yourself to the list of known Y instances in testconnector.
   * Also initiate sync with all clients.
@@ -83,6 +86,7 @@ export class TestYInstance extends Doc {
      })
    }
  }
+
  /**
   * Receive a message from another client. This message is only appended to the list of receiving messages.
   * TestConnector decides when this client actually reads this message.
@@ -124,6 +128,7 @@ export class TestConnector {
     */
    this.prng = gen
  }
+
  /**
   * Create a new Y instance and add it to the list of connections
   * @param {number} clientID
@@ -131,6 +136,7 @@ export class TestConnector {
  createY (clientID) {
    return new TestYInstance(this, clientID)
  }
+
  /**
   * Choose random connection and flush a random message from a random sender.
   *
@@ -162,6 +168,7 @@ export class TestConnector {
    }
    return false
  }
+
  /**
   * @return {boolean} True iff this function actually flushed something
   */
@@ -172,16 +179,20 @@ export class TestConnector {
    }
    return didSomething
  }
+
  reconnectAll () {
    this.allConns.forEach(conn => conn.connect())
  }
+
  disconnectAll () {
    this.allConns.forEach(conn => conn.disconnect())
  }
+
  syncAll () {
    this.reconnectAll()
    this.flushAllMessages()
  }
+
  /**
   * @return {boolean} Whether it was possible to disconnect a randon connection.
   */
@@ -192,6 +203,7 @@ export class TestConnector {
    prng.oneOf(this.prng, Array.from(this.onlineConns)).disconnect()
    return true
  }
+
  /**
   * @return {boolean} Whether it was possible to reconnect a random connection.
   */
@@ -266,13 +278,16 @@ export const compare = users => {
    t.assert(u.store.pendingClientsStructRefs.size === 0)
  }
  // Test Array iterator
-  t.compare(userArrayValues[0], Array.from(users[0].getArray('array').toJSON()))
+  t.compare(users[0].getArray('array').toArray(), Array.from(users[0].getArray('array')))
  // Test Map iterator
+  const ymapkeys = Array.from(users[0].getMap('map').keys())
+  t.assert(ymapkeys.length === Object.keys(userMapValues[0]).length)
+  ymapkeys.forEach(key => t.assert(object.hasProperty(userMapValues[0], key)))
  /**
   * @type {Object<string,any>}
   */
  const mapRes = {}
-  for (let [k, v] of users[0].getMap('map')) {
+  for (const [k, v] of users[0].getMap('map')) {
    mapRes[k] = v instanceof Y.AbstractType ? v.toJSON() : v
  }
  t.compare(userMapValues[0], mapRes)
@@ -282,7 +297,7 @@ export const compare = users => {
    t.compare(userArrayValues[i], userArrayValues[i + 1])
    t.compare(userMapValues[i], userMapValues[i + 1])
    t.compare(userXmlValues[i], userXmlValues[i + 1])
-    t.compare(userTextValues[i].map(/** @param {any} a */ a => a.insert).join('').length, users[i].getText('text').length)
+    t.compare(userTextValues[i].map(/** @param {any} a */ a => typeof a.insert === 'string' ? a.insert : ' ').join('').length, users[i].getText('text').length)
    t.compare(userTextValues[i], userTextValues[i + 1])
    t.compare(getStateVector(users[i].store), getStateVector(users[i + 1].store))
    compareDS(createDeleteSetFromStructStore(users[i].store), createDeleteSetFromStructStore(users[i + 1].store))
@@ -375,7 +390,7 @@ export const compareDS = (ds1, ds2) => {
 */
 export const applyRandomTests = (tc, mods, iterations, initTestObject) => {
  const gen = tc.prng
-  const result = init(tc, { users: 5 }, initTestObject || (() => null))
+  const result = init(tc, { users: 5 }, initTestObject)
  const { testConnector, users } = result
  for (let i = 0; i < iterations; i++) {
    if (prng.int31(gen, 0, 100) <= 2) {
--- a/tests/undo-redo.tests.js
+++ b/tests/undo-redo.tests.js
@@ -0,0 +1,248 @@
+import { init, compare, applyRandomTests, Doc } from './testHelper.js' // eslint-disable-line
+
+import {
+  UndoManager
+} from '../src/internals.js'
+
+import * as Y from '../src/index.js'
+import * as t from 'lib0/testing.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoText = tc => {
+  const { testConnector, text0, text1 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(text0)
+
+  // items that are added & deleted in the same transaction won't be undo
+  text0.insert(0, 'test')
+  text0.delete(0, 4)
+  undoManager.undo()
+  t.assert(text0.toString() === '')
+
+  // follow redone items
+  text0.insert(0, 'a')
+  undoManager.stopCapturing()
+  text0.delete(0, 1)
+  undoManager.stopCapturing()
+  undoManager.undo()
+  t.assert(text0.toString() === 'a')
+  undoManager.undo()
+  t.assert(text0.toString() === '')
+
+  text0.insert(0, 'abc')
+  text1.insert(0, 'xyz')
+  testConnector.syncAll()
+  undoManager.undo()
+  t.assert(text0.toString() === 'xyz')
+  undoManager.redo()
+  t.assert(text0.toString() === 'abcxyz')
+  testConnector.syncAll()
+  text1.delete(0, 1)
+  testConnector.syncAll()
+  undoManager.undo()
+  t.assert(text0.toString() === 'xyz')
+  undoManager.redo()
+  t.assert(text0.toString() === 'bcxyz')
+  // test marks
+  text0.format(1, 3, { bold: true })
+  t.compare(text0.toDelta(), [{ insert: 'b' }, { insert: 'cxy', attributes: { bold: true } }, { insert: 'z' }])
+  undoManager.undo()
+  t.compare(text0.toDelta(), [{ insert: 'bcxyz' }])
+  undoManager.redo()
+  t.compare(text0.toDelta(), [{ insert: 'b' }, { insert: 'cxy', attributes: { bold: true } }, { insert: 'z' }])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoMap = tc => {
+  const { testConnector, map0, map1 } = init(tc, { users: 2 })
+  map0.set('a', 0)
+  const undoManager = new UndoManager(map0)
+  map0.set('a', 1)
+  undoManager.undo()
+  t.assert(map0.get('a') === 0)
+  undoManager.redo()
+  t.assert(map0.get('a') === 1)
+  // testing sub-types and if it can restore a whole type
+  const subType = new Y.Map()
+  map0.set('a', subType)
+  subType.set('x', 42)
+  t.compare(map0.toJSON(), /** @type {any} */ ({ a: { x: 42 } }))
+  undoManager.undo()
+  t.assert(map0.get('a') === 1)
+  undoManager.redo()
+  t.compare(map0.toJSON(), /** @type {any} */ ({ a: { x: 42 } }))
+  testConnector.syncAll()
+  // if content is overwritten by another user, undo operations should be skipped
+  map1.set('a', 44)
+  testConnector.syncAll()
+  undoManager.undo()
+  t.assert(map0.get('a') === 44)
+  undoManager.redo()
+  t.assert(map0.get('a') === 44)
+
+  // test setting value multiple times
+  map0.set('b', 'initial')
+  undoManager.stopCapturing()
+  map0.set('b', 'val1')
+  map0.set('b', 'val2')
+  undoManager.stopCapturing()
+  undoManager.undo()
+  t.assert(map0.get('b') === 'initial')
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoArray = tc => {
+  const { testConnector, array0, array1 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(array0)
+  array0.insert(0, [1, 2, 3])
+  array1.insert(0, [4, 5, 6])
+  testConnector.syncAll()
+  t.compare(array0.toArray(), [1, 2, 3, 4, 5, 6])
+  undoManager.undo()
+  t.compare(array0.toArray(), [4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toArray(), [1, 2, 3, 4, 5, 6])
+  testConnector.syncAll()
+  array1.delete(0, 1) // user1 deletes [1]
+  testConnector.syncAll()
+  undoManager.undo()
+  t.compare(array0.toArray(), [4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toArray(), [2, 3, 4, 5, 6])
+  array0.delete(0, 5)
+  // test nested structure
+  const ymap = new Y.Map()
+  array0.insert(0, [ymap])
+  t.compare(array0.toJSON(), [{}])
+  undoManager.stopCapturing()
+  ymap.set('a', 1)
+  t.compare(array0.toJSON(), [{ a: 1 }])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [{}])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [2, 3, 4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{}])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{ a: 1 }])
+  testConnector.syncAll()
+  array1.get(0).set('b', 2)
+  testConnector.syncAll()
+  t.compare(array0.toJSON(), [{ a: 1, b: 2 }])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [{ b: 2 }])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [2, 3, 4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{ b: 2 }])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{ a: 1, b: 2 }])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoXml = tc => {
+  const { xml0 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(xml0)
+  const child = new Y.XmlElement('p')
+  xml0.insert(0, [child])
+  const textchild = new Y.XmlText('content')
+  child.insert(0, [textchild])
+  t.assert(xml0.toString() === '<undefined><p>content</p></undefined>')
+  // format textchild and revert that change
+  undoManager.stopCapturing()
+  textchild.format(3, 4, { bold: {} })
+  t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
+  undoManager.undo()
+  t.assert(xml0.toString() === '<undefined><p>content</p></undefined>')
+  undoManager.redo()
+  t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
+  xml0.delete(0, 1)
+  t.assert(xml0.toString() === '<undefined></undefined>')
+  undoManager.undo()
+  t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoEvents = tc => {
+  const { text0 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(text0)
+  let counter = 0
+  let receivedMetadata = -1
+  undoManager.on('stack-item-added', /** @param {any} event */ event => {
+    t.assert(event.type != null)
+    event.stackItem.meta.set('test', counter++)
+  })
+  undoManager.on('stack-item-popped', /** @param {any} event */ event => {
+    t.assert(event.type != null)
+    receivedMetadata = event.stackItem.meta.get('test')
+  })
+  text0.insert(0, 'abc')
+  undoManager.undo()
+  t.assert(receivedMetadata === 0)
+  undoManager.redo()
+  t.assert(receivedMetadata === 1)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testTrackClass = tc => {
+  const { users, text0 } = init(tc, { users: 3 })
+  // only track origins that are numbers
+  const undoManager = new UndoManager(text0, { trackedOrigins: new Set([Number]) })
+  users[0].transact(() => {
+    text0.insert(0, 'abc')
+  }, 42)
+  t.assert(text0.toString() === 'abc')
+  undoManager.undo()
+  t.assert(text0.toString() === '')
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testTypeScope = tc => {
+  const { array0 } = init(tc, { users: 3 })
+  // only track origins that are numbers
+  const text0 = new Y.Text()
+  const text1 = new Y.Text()
+  array0.insert(0, [text0, text1])
+  const undoManager = new UndoManager(text0)
+  const undoManagerBoth = new UndoManager([text0, text1])
+  text1.insert(0, 'abc')
+  t.assert(undoManager.undoStack.length === 0)
+  t.assert(undoManagerBoth.undoStack.length === 1)
+  t.assert(text1.toString() === 'abc')
+  undoManager.undo()
+  t.assert(text1.toString() === 'abc')
+  undoManagerBoth.undo()
+  t.assert(text1.toString() === '')
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoDeleteFilter = tc => {
+  /**
+   * @type {Array<Y.Map<any>>}
+   */
+  const array0 = /** @type {any} */ (init(tc, { users: 3 }).array0)
+  const undoManager = new UndoManager(array0, { deleteFilter: item => !(item instanceof Y.Item) || (item.content instanceof Y.ContentType && item.content.type._map.size === 0) })
+  const map0 = new Y.Map()
+  map0.set('hi', 1)
+  const map1 = new Y.Map()
+  array0.insert(0, [map0, map1])
+  undoManager.undo()
+  t.assert(array0.length === 1)
+  array0.get(0)
+  t.assert(Array.from(array0.get(0).keys()).length === 1)
+}
--- a/tests/y-array.tests.js
+++ b/tests/y-array.tests.js
@@ -3,6 +3,7 @@ import { init, compare, applyRandomTests, Doc } from './testHelper.js' // eslint
 import * as Y from '../src/index.js'
 import * as t from 'lib0/testing.js'
 import * as prng from 'lib0/prng.js'
+import * as math from 'lib0/math.js'

 /**
 * @param {t.TestCase} tc
@@ -191,6 +192,33 @@ export const testInsertAndDeleteEventsForTypes = tc => {
  compare(users)
 }

+/**
+ * @param {t.TestCase} tc
+ */
+export const testChangeEvent = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  /**
+   * @type {any}
+   */
+  let changes = null
+  array0.observe(e => {
+    changes = e.changes
+  })
+  const newArr = new Y.Array()
+  array0.insert(0, [newArr, 4, 'dtrn'])
+  t.assert(changes !== null && changes.added.size === 2 && changes.deleted.size === 0)
+  t.compare(changes.delta, [{ insert: [newArr, 4, 'dtrn'] }])
+  changes = null
+  array0.delete(0, 2)
+  t.assert(changes !== null && changes.added.size === 0 && changes.deleted.size === 2)
+  t.compare(changes.delta, [{ delete: 2 }])
+  changes = null
+  array0.insert(1, [0.1])
+  t.assert(changes !== null && changes.added.size === 1 && changes.deleted.size === 0)
+  t.compare(changes.delta, [{ retain: 1 }, { insert: [0.1] }])
+  compare(users)
+}
+
 /**
 * @param {t.TestCase} tc
 */
@@ -199,7 +227,7 @@ export const testInsertAndDeleteEventsForTypes2 = tc => {
  /**
   * @type {Array<Object<string,any>>}
   */
-  let events = []
+  const events = []
  array0.observe(e => {
    events.push(e)
  })
@@ -210,6 +238,24 @@ export const testInsertAndDeleteEventsForTypes2 = tc => {
  compare(users)
 }

+/**
+ * This issue has been reported here https://github.com/yjs/yjs/issues/155
+ * @param {t.TestCase} tc
+ */
+export const testNewChildDoesNotEmitEventInTransaction = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  let fired = false
+  users[0].transact(() => {
+    const newMap = new Y.Map()
+    newMap.observe(() => {
+      fired = true
+    })
+    array0.insert(0, [newMap])
+    newMap.set('tst', 42)
+  })
+  t.assert(!fired, 'Event does not trigger')
+}
+
 /**
 * @param {t.TestCase} tc
 */
@@ -272,7 +318,7 @@ export const testIteratingArrayContainingTypes = tc => {
    arr.push([map])
  }
  let cnt = 0
-  for (let item of arr) {
+  for (const item of arr) {
    t.assert(item.get('value') === cnt++, 'value is correct')
  }
  y.destroy()
@@ -317,12 +363,12 @@ const arrayTransactions = [
    var length = yarray.length
    if (length > 0) {
      var somePos = prng.int31(gen, 0, length - 1)
-      var delLength = prng.int31(gen, 1, Math.min(2, length - somePos))
+      var delLength = prng.int31(gen, 1, math.min(2, length - somePos))
      if (prng.bool(gen)) {
        var type = yarray.get(somePos)
        if (type.length > 0) {
          somePos = prng.int31(gen, 0, type.length - 1)
-          delLength = prng.int31(gen, 0, Math.min(2, type.length - somePos))
+          delLength = prng.int31(gen, 0, math.min(2, type.length - somePos))
          type.delete(somePos, delLength)
        }
      } else {
--- a/tests/y-map.tests.js
+++ b/tests/y-map.tests.js
@@ -66,7 +66,7 @@ export const testGetAndSetOfMapProperty = tc => {

  testConnector.flushAllMessages()

-  for (let user of users) {
+  for (const user of users) {
    const u = user.getMap('map')
    t.compare(u.get('stuff'), 'stuffy')
    t.assert(u.get('undefined') === undefined, 'undefined')
@@ -108,7 +108,7 @@ export const testGetAndSetOfMapPropertySyncs = tc => {
  map0.set('stuff', 'stuffy')
  t.compare(map0.get('stuff'), 'stuffy')
  testConnector.flushAllMessages()
-  for (let user of users) {
+  for (const user of users) {
    var u = user.getMap('map')
    t.compare(u.get('stuff'), 'stuffy')
  }
@@ -123,7 +123,7 @@ export const testGetAndSetOfMapPropertyWithConflict = tc => {
  map0.set('stuff', 'c0')
  map1.set('stuff', 'c1')
  testConnector.flushAllMessages()
-  for (let user of users) {
+  for (const user of users) {
    var u = user.getMap('map')
    t.compare(u.get('stuff'), 'c1')
  }
@@ -139,7 +139,7 @@ export const testGetAndSetAndDeleteOfMapProperty = tc => {
  map1.set('stuff', 'c1')
  map1.delete('stuff')
  testConnector.flushAllMessages()
-  for (let user of users) {
+  for (const user of users) {
    var u = user.getMap('map')
    t.assert(u.get('stuff') === undefined)
  }
@@ -156,7 +156,7 @@ export const testGetAndSetOfMapPropertyWithThreeConflicts = tc => {
  map1.set('stuff', 'c2')
  map2.set('stuff', 'c3')
  testConnector.flushAllMessages()
-  for (let user of users) {
+  for (const user of users) {
    var u = user.getMap('map')
    t.compare(u.get('stuff'), 'c3')
  }
@@ -179,7 +179,7 @@ export const testGetAndSetAndDeleteOfMapPropertyWithThreeConflicts = tc => {
  map3.set('stuff', 'c3')
  map3.delete('stuff')
  testConnector.flushAllMessages()
-  for (let user of users) {
+  for (const user of users) {
    var u = user.getMap('map')
    t.assert(u.get('stuff') === undefined)
  }
@@ -292,6 +292,104 @@ export const testThrowsAddAndUpdateAndDeleteEvents = tc => {
  compare(users)
 }

+/**
+ * @param {t.TestCase} tc
+ */
+export const testChangeEvent = tc => {
+  const { map0, users } = init(tc, { users: 2 })
+  /**
+   * @type {any}
+   */
+  let changes = null
+  /**
+   * @type {any}
+   */
+  let keyChange = null
+  map0.observe(e => {
+    changes = e.changes
+  })
+  map0.set('a', 1)
+  keyChange = changes.keys.get('a')
+  t.assert(changes !== null && keyChange.action === 'add' && keyChange.oldValue === undefined)
+  map0.set('a', 2)
+  keyChange = changes.keys.get('a')
+  t.assert(changes !== null && keyChange.action === 'update' && keyChange.oldValue === 1)
+  users[0].transact(() => {
+    map0.set('a', 3)
+    map0.set('a', 4)
+  })
+  keyChange = changes.keys.get('a')
+  t.assert(changes !== null && keyChange.action === 'update' && keyChange.oldValue === 2)
+  users[0].transact(() => {
+    map0.set('b', 1)
+    map0.set('b', 2)
+  })
+  keyChange = changes.keys.get('b')
+  t.assert(changes !== null && keyChange.action === 'add' && keyChange.oldValue === undefined)
+  users[0].transact(() => {
+    map0.set('c', 1)
+    map0.delete('c')
+  })
+  t.assert(changes !== null && changes.keys.size === 0)
+  users[0].transact(() => {
+    map0.set('d', 1)
+    map0.set('d', 2)
+  })
+  keyChange = changes.keys.get('d')
+  t.assert(changes !== null && keyChange.action === 'add' && keyChange.oldValue === undefined)
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testYmapEventExceptionsShouldCompleteTransaction = tc => {
+  const doc = new Y.Doc()
+  const map = doc.getMap('map')
+
+  let updateCalled = false
+  let throwingObserverCalled = false
+  let throwingDeepObserverCalled = false
+  doc.on('update', () => {
+    updateCalled = true
+  })
+
+  const throwingObserver = () => {
+    throwingObserverCalled = true
+    throw new Error('Failure')
+  }
+
+  const throwingDeepObserver = () => {
+    throwingDeepObserverCalled = true
+    throw new Error('Failure')
+  }
+
+  map.observe(throwingObserver)
+  map.observeDeep(throwingDeepObserver)
+
+  t.fails(() => {
+    map.set('y', '2')
+  })
+
+  t.assert(updateCalled)
+  t.assert(throwingObserverCalled)
+  t.assert(throwingDeepObserverCalled)
+
+  // check if it works again
+  updateCalled = false
+  throwingObserverCalled = false
+  throwingDeepObserverCalled = false
+  t.fails(() => {
+    map.set('z', '3')
+  })
+
+  t.assert(updateCalled)
+  t.assert(throwingObserverCalled)
+  t.assert(throwingDeepObserverCalled)
+
+  t.assert(map.get('z') === '3')
+}
+
 /**
 * @param {t.TestCase} tc
 */
@@ -332,12 +430,12 @@ export const testYmapEventHasCorrectValueWhenSettingAPrimitiveFromOtherUser = tc
 */
 const mapTransactions = [
  function set (user, gen) {
-    let key = prng.oneOf(gen, ['one', 'two'])
+    const key = prng.oneOf(gen, ['one', 'two'])
    var value = prng.utf16String(gen)
    user.getMap('map').set(key, value)
  },
  function setType (user, gen) {
-    let key = prng.oneOf(gen, ['one', 'two'])
+    const key = prng.oneOf(gen, ['one', 'two'])
    var type = prng.oneOf(gen, [new Y.Array(), new Y.Map()])
    user.getMap('map').set(key, type)
    if (type instanceof Y.Array) {
@@ -347,7 +445,7 @@ const mapTransactions = [
    }
  },
  function _delete (user, gen) {
-    let key = prng.oneOf(gen, ['one', 'two'])
+    const key = prng.oneOf(gen, ['one', 'two'])
    user.getMap('map').delete(key)
  }
 ]
--- a/tests/y-text.tests.js
+++ b/tests/y-text.tests.js
@@ -1,6 +1,6 @@
-import { init, compare } from './testHelper.js'
-
+import * as Y from './testHelper.js'
 import * as t from 'lib0/testing.js'
+const { init, compare } = Y

 /**
 * @param {t.TestCase} tc
@@ -81,9 +81,80 @@ export const testBasicFormat = tc => {
 export const testGetDeltaWithEmbeds = tc => {
  const { text0 } = init(tc, { users: 1 })
  text0.applyDelta([{
-    insert: {linebreak: 's'}
+    insert: { linebreak: 's' }
  }])
  t.compare(text0.toDelta(), [{
-    insert: {linebreak: 's'}
+    insert: { linebreak: 's' }
  }])
 }
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testSnapshot = tc => {
+  const { text0 } = init(tc, { users: 1 })
+  const doc0 = /** @type {Y.Doc} */ (text0.doc)
+  doc0.gc = false
+  text0.applyDelta([{
+    insert: 'abcd'
+  }])
+  const snapshot1 = Y.snapshot(doc0)
+  text0.applyDelta([{
+    retain: 1
+  }, {
+    insert: 'x'
+  }, {
+    delete: 1
+  }])
+  const snapshot2 = Y.snapshot(doc0)
+  text0.applyDelta([{
+    retain: 2
+  }, {
+    delete: 3
+  }, {
+    insert: 'x'
+  }, {
+    delete: 1
+  }])
+  const state1 = text0.toDelta(snapshot1)
+  t.compare(state1, [{ insert: 'abcd' }])
+  const state2 = text0.toDelta(snapshot2)
+  t.compare(state2, [{ insert: 'axcd' }])
+  const state2Diff = text0.toDelta(snapshot2, snapshot1)
+  // @ts-ignore Remove userid info
+  state2Diff.forEach(v => {
+    if (v.attributes && v.attributes.ychange) {
+      delete v.attributes.ychange.user
+    }
+  })
+  t.compare(state2Diff, [{ insert: 'a' }, { insert: 'x', attributes: { ychange: { type: 'added' } } }, { insert: 'b', attributes: { ychange: { type: 'removed' } } }, { insert: 'cd' }])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testSnapshotDeleteAfter = tc => {
+  const { text0 } = init(tc, { users: 1 })
+  const doc0 = /** @type {Y.Doc} */ (text0.doc)
+  doc0.gc = false
+  text0.applyDelta([{
+    insert: 'abcd'
+  }])
+  const snapshot1 = Y.snapshot(doc0)
+  text0.applyDelta([{
+    retain: 4
+  }, {
+    insert: 'e'
+  }])
+  const state1 = text0.toDelta(snapshot1)
+  t.compare(state1, [{ insert: 'abcd' }])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testToJson = tc => {
+  const { text0 } = init(tc, { users: 1 })
+  text0.insert(0, 'abc', { bold: true })
+  t.assert(text0.toJSON() === 'abc', 'toJSON returns the unformatted text')
+}
--- a/tests/y-xml.tests.js
+++ b/tests/y-xml.tests.js
@@ -60,13 +60,13 @@ export const testEvents = tc => {
 */
 export const testTreewalker = tc => {
  const { users, xml0 } = init(tc, { users: 3 })
-  let paragraph1 = new Y.XmlElement('p')
-  let paragraph2 = new Y.XmlElement('p')
-  let text1 = new Y.XmlText('init')
-  let text2 = new Y.XmlText('text')
+  const paragraph1 = new Y.XmlElement('p')
+  const paragraph2 = new Y.XmlElement('p')
+  const text1 = new Y.XmlText('init')
+  const text2 = new Y.XmlText('text')
  paragraph1.insert(0, [text1, text2])
  xml0.insert(0, [paragraph1, paragraph2, new Y.XmlElement('img')])
-  let allParagraphs = xml0.querySelectorAll('p')
+  const allParagraphs = xml0.querySelectorAll('p')
  t.assert(allParagraphs.length === 2, 'found exactly two paragraphs')
  t.assert(allParagraphs[0] === paragraph1, 'querySelectorAll found paragraph1')
  t.assert(allParagraphs[1] === paragraph2, 'querySelectorAll found paragraph2')
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,15 +6,15 @@
    "allowJs": true,                       /* Allow javascript files to be compiled. */
    "checkJs": true,                       /* Report errors in .js files. */
    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    "declaration": true,                   /* Generates corresponding '.d.ts' file. */
    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
-    // "outFile": "./",                       /* Concatenate and emit output to single file. */
-    // "outDir": "./build",                        /* Redirect output structure to the directory. */
-    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "outFile": "./dist/yjs.js",                       /* Concatenate and emit output to single file. */
+    "outDir": "./dist",                        /* Redirect output structure to the directory. */
+    "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
    // "composite": true,                     /* Enable project compilation */
    // "removeComments": true,                /* Do not emit comments to output. */
-    "noEmit": true,                        /* Do not emit outputs. */
+    // "noEmit": true,                        /* Do not emit outputs. */
    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
@@ -22,6 +22,7 @@
    /* Strict Type-Checking Options */
    "strict": true,                           /* Enable all strict type-checking options. */
    "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    "emitDeclarationOnly": true,
    // "strictNullChecks": true,              /* Enable strict null checks. */
    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
@@ -38,7 +39,10 @@
    "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
    "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
    "paths": {
-      "yjs": ["./src/index.js"]
+      "yjs": ["./src/index.js"],
+      "lib0/*": ["node_modules/lib0/*"],
+      "lib0/set.js": ["node_modules/lib0/set.js"],
+      "lib0/function.js": ["node_modules/lib0/function.js"]
    },                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
    // "typeRoots": [],                       /* List of folders to include type definitions from. */
@@ -59,6 +63,6 @@
    "maxNodeModuleJsDepth": 5,
    // "types": ["./src/utils/typedefs.js"]
  },
-  "include": ["./src/**/*", "./tests/**/*"],
+  "include": ["./src/**/*.js", "./tests/**/*.js"],
  "exclude": ["../lib0/**/*", "node_modules/**/*", "dist", "dist/**/*.js"]
 }
Author	SHA1	Message	Date
Kevin Jahns	76c389dba0	13.0.2	2020-02-03 12:23:39 +01:00
Kevin Jahns	78fa98c000	add type definition for YText.length	2020-02-03 12:22:35 +01:00
Kevin Jahns	e9f9e08450	13.0.1	2020-01-27 03:43:45 +01:00
Kevin Jahns	e3c59b0aa7	more options to gc data (undomanager.clear and tryGc)	2020-01-27 03:42:32 +01:00
Kevin Jahns	705dce7838	add y-indexeddb section	2020-01-23 22:49:04 +01:00
Kevin Jahns	0fb55981ba	13.0.0	2020-01-23 21:53:02 +01:00
Kevin Jahns	89378e29ae	publish stable Yjs release 🎆	2020-01-23 21:51:26 +01:00
Kevin Jahns	cce35270ec	typescript typingis!!! fixes #180	2020-01-23 21:45:56 +01:00
Kevin Jahns	d78180bf97	make opts optional in PermanentUserData	2020-01-23 18:05:12 +01:00
Kevin Jahns	0ab415de3e	13.0.0-108	2020-01-23 05:01:05 +01:00
Kevin Jahns	ff3969caeb	dedupe npm	2020-01-23 05:00:11 +01:00
Kevin Jahns	c82cc9f8d6	lint	2020-01-23 04:59:17 +01:00
Kevin Jahns	ef5c71bd8b	PermanentUserData fixes	2020-01-23 04:58:02 +01:00
Kevin Jahns	bd6be3d23b	13.0.0-107	2020-01-22 16:45:48 +01:00
Kevin Jahns	0e6deab9c9	type toJSON returns	2020-01-22 16:44:30 +01:00
Kevin Jahns	6cd9e2be32	lint	2020-01-22 16:42:16 +01:00
Kevin Jahns	ac8dab1e88	Merge pull request #179 from garth/text-tojson basic Y.Text toJSON returns {unformatted:string}	2020-01-22 16:19:01 +01:00
Garth Williams	38ed725c2c	basic Y.Text toJSON returns unformatted string This avoids text nodes in nested structures returning undefined when toJSON is called by a parent.	2020-01-22 13:34:13 +01:00
Kevin Jahns	a210bad25e	update keywords	2020-01-19 00:43:23 +01:00
Kevin Jahns	6929a4f0f8	13.0.0-106	2020-01-14 05:16:43 +01:00
Kevin Jahns	52dacfa5f2	update package-lock	2020-01-14 05:15:36 +01:00
Kevin Jahns	27efe86f9c	isParentOf	2020-01-14 05:13:51 +01:00
Kevin Jahns	882b9055c7	fix localimports path ending	2020-01-14 02:36:29 +01:00
Kevin Jahns	e089089413	fix debug resolve	2020-01-13 17:03:56 +01:00
Kevin Jahns	197932752e	13.0.0-105	2020-01-13 14:55:05 +01:00
Kevin Jahns	f0b2bdaf34	revert to classic cjs module	2020-01-13 14:54:07 +01:00
Kevin Jahns	b96362c0f1	use correct module script	2020-01-13 07:55:58 +01:00
Kevin Jahns	67f241cd7a	13.0.0-104	2020-01-13 07:48:47 +01:00
Kevin Jahns	c8af0bebf7	fix preversion script	2020-01-13 07:47:43 +01:00
Kevin Jahns	4f35e799a6	update to lib0@.2	2020-01-13 07:41:31 +01:00
Kevin Jahns	eb2a52dd26	update README with podcast links, consulting info, and y-webrtc	2019-12-11 13:26:46 +01:00
Kevin Jahns	189b1068ae	13.0.0-103	2019-12-10 20:52:20 +01:00
Kevin Jahns	7a3b60a5d7	add markdownlint-cli as dep	2019-12-10 20:51:07 +01:00
Kevin Jahns	99f06fc093	bump lib0 for improved encoding performance	2019-12-10 20:46:58 +01:00
Kevin Jahns	22917bca19	fix gc & proper options typings for Y.Doc, fixes #176	2019-12-10 17:51:49 +01:00
Kevin Jahns	7f0e25dcba	permanent user store writes updates in separate transaction	2019-12-10 17:18:57 +01:00
Kevin Jahns	d90c9b1cb2	bump lib0 for faster text encoding	2019-12-10 00:26:28 +01:00
Kevin Jahns	c426055f17	spelling	2019-12-10 00:19:02 +01:00
Kevin Jahns	18c9010b63	Merge branch 'master' of github.com:y-js/yjs	2019-11-26 13:02:49 +01:00
Kevin Jahns	c3edac62ef	doc typo	2019-11-26 13:02:43 +01:00
Kevin Jahns	755de18fd5	Create Funding.yml	2019-11-07 14:41:50 +01:00
Kevin Jahns	641dc25076	13.0.0-102	2019-10-25 23:47:23 +02:00
Kevin Jahns	1d58ea785f	Merge branch 'master' of github.com:yjs/yjs	2019-10-25 23:45:50 +02:00
Kevin Jahns	f53dff5043	delay errors in observe callbacks to throw after cleanup is done	2019-10-25 23:44:09 +02:00
Kevin Jahns	74d1a31f49	Merge pull request #174 from boschDev/master Fix attrs loop in yXmlText	2019-10-15 17:19:30 +02:00
Roeland Bosch	d1063ab70b	Fix attrs loop in yXmlText	2019-10-15 17:07:20 +02:00
Kevin Jahns	f4c919d9ec	13.0.0-101	2019-10-08 18:33:50 +02:00
Kevin Jahns	aeb23dbaa9	follow redone items to prevent some undo-redo issues. Fixes #162	2019-10-08 18:31:56 +02:00
Kevin Jahns	6d4f0c0cdd	13.0.0-100	2019-10-08 17:40:32 +02:00
Kevin Jahns	303138f309	sanitize items before undoing. fixes #165	2019-10-08 17:36:00 +02:00
Kevin Jahns	ad373a3dce	Merge pull request #172 from istvank/patch-1 Fixing Y.Map's documentation of forEach	2019-10-05 20:09:53 +02:00
István Koren	2150fa58f2	Fixing Y.Map's documentation of forEach fixes #171 As always, it's an honor to submit a PR! 🐒 There was also a missing dot in the Y.XmlFragment title.	2019-10-05 15:14:30 +02:00
Kevin Jahns	ece4841b5c	update stackItem.meta doc	2019-10-03 22:06:07 +02:00
Kevin Jahns	8103220c05	Merge branch 'master' of github.com:yjs/yjs	2019-09-30 11:10:13 +02:00
Kevin Jahns	66d500f08d	YEvent: consider case that item was added & removed in the same transaction	2019-09-30 11:10:03 +02:00
Kevin Jahns	5f8e7c7ba7	Merge pull request #169 from yjs/improve-readme update quill cursors support	2019-09-23 11:22:51 +02:00
Nik Graf	7b8eee6b25	update quill cursors support	2019-09-23 11:22:24 +02:00
Kevin Jahns	1d5947c602	13.0.0-99	2019-09-23 11:11:45 +02:00
Kevin Jahns	53e4028952	Merge pull request #168 from yjs/fix-absolute-position-calculation fix absolute position calculation	2019-09-23 11:09:48 +02:00
Nik Graf	b38a8d99e5	fix absolute position calculation	2019-09-23 11:05:50 +02:00
Kevin Jahns	6c4971ae25	13.0.0-98	2019-09-17 18:55:04 +02:00
Kevin Jahns	d1f5ff0f59	implement PermanentUserData storage prototype	2019-09-17 18:53:59 +02:00
Kevin Jahns	1d297601e8	export .createDeleteSet functionality	2019-09-04 22:08:05 +02:00
Kevin Jahns	d9fface0be	13.0.0-97	2019-09-04 13:21:10 +02:00
Kevin Jahns	7d5db917da	fix type error >= tsc@3.6	2019-09-04 13:19:25 +02:00
Kevin Jahns	6e7529723d	update lib0	2019-09-04 13:15:34 +02:00
Kevin Jahns	6cb64b3707	move repository to yjs org	2019-09-04 13:08:34 +02:00
Kevin Jahns	bb1c0b809f	implement snapshot & event.changes	2019-09-03 16:33:29 +02:00
Kevin Jahns	8bcff6138c	Y.Text snapshot support (toDelta)	2019-08-31 22:42:18 +02:00
Kevin Jahns	e78d84ee59	md lint	2019-08-31 16:47:12 +02:00
Kevin Jahns	c23bcb66ce	delta format: use flat attr comparison	2019-08-31 16:44:07 +02:00
Kevin Jahns	5fddcef3ea	Update logo	2019-08-29 12:51:16 +02:00
Kevin Jahns	e1e46c6eb1	Merge branch 'master' of github.com:y-js/yjs	2019-08-27 02:17:16 +02:00
Kevin Jahns	13ad0c8464	implement Y.XmlFragment.length	2019-08-27 02:17:08 +02:00
Kevin Jahns	7700b50470	Merge pull request #161 from blackening/master Updated documentation for Y.Array forEach	2019-08-20 23:18:46 +02:00
Kevin Jahns	fc4d6165b4	13.0.0-96	2019-08-20 22:29:56 +02:00
Kevin Jahns	251c8aaefc	UndoManager configuration to filter deletes	2019-08-20 22:28:49 +02:00
Kevin Jahns	1337d38ada	13.0.0-95	2019-08-09 01:18:15 +02:00
Kevin Jahns	f5c66e41cb	audit	2019-08-09 01:16:40 +02:00
Kevin Jahns	0e7da017fe	Use lib0/any-encoding instead of JSON	2019-08-09 01:15:46 +02:00
blackening	f0262ffaae	Updated documentation for Y.Array forEach Reference: https://github.com/y-js/yjs/blob/master/src/types/YArray.js#L186 https://github.com/y-js/yjs/blob/master/src/types/AbstractType.js#L239	2019-07-09 19:58:06 +08:00
Kevin Jahns	36203af88e	should not rely on all deconstructing features because not all parsers support it	2019-06-29 14:47:34 +02:00
Kevin Jahns	dd2b8bc6c7	13.0.0-94	2019-06-25 11:57:50 +02:00
Kevin Jahns	463065ac21	UndoManager: keep item before item is deleted (fixes some edge cases of followRedo)	2019-06-25 11:56:41 +02:00
Kevin Jahns	d064e6e96e	UndoManager accepts an array of types as scope. Implements #156	2019-06-25 02:26:18 +02:00
Kevin Jahns	b1ed2df208	proper TOC links	2019-06-25 00:10:12 +02:00
Kevin Jahns	1fe4ef135c	13.0.0-93	2019-06-24 23:06:11 +02:00
Kevin Jahns	e376b5d472	UndoManager fixes	2019-06-24 23:04:53 +02:00
Kevin Jahns	952a9b2c41	13.0.0-92	2019-06-23 13:05:30 +02:00
Kevin Jahns	03458dc641	Port Undo/Redo approach with a clean API	2019-06-23 13:04:14 +02:00
Kevin Jahns	14df5b72af	fix consistency bug - ref.toStruct does not correctly create GC when offset is specified	2019-06-18 18:46:19 +02:00
Kevin Jahns	338968031b	13.0.0-91	2019-06-18 18:05:39 +02:00
Kevin Jahns	1aac245b93	New types dont fire events - fixes #155	2019-06-18 17:41:19 +02:00
Kevin Jahns	1faff323c1	13.0.0-90	2019-06-14 16:00:02 +02:00
Kevin Jahns	e7280c7ae2	allow case sensitive yxml nodes	2019-06-14 15:59:00 +02:00
Kevin Jahns	4c38619b5d	13.0.0-89	2019-06-13 10:33:35 +02:00
Kevin Jahns	b4e5c5cc1f	Correctly insert embed when using YText.applyDelta	2019-06-13 10:30:39 +02:00
Kevin Jahns	b0dbd84f7f	lint markdown	2019-06-13 10:28:30 +02:00
Kevin Jahns	4a990963d9	13.0.0-88	2019-06-05 18:37:21 +02:00
Kevin Jahns	7e7c9d5b11	add relevant type information	2019-06-05 14:53:00 +02:00
Kevin Jahns	775f6eed1d	fix websocket example	2019-06-02 15:16:14 +02:00