13.6.2

implement snapshotContainsUpdate
Merge pull request #528 from jamesgpearce/patch-1
2023-06-08 11:19:06 +02:00 · 2023-06-08 11:14:49 +02:00 · 2023-05-05 12:21:56 +02:00 · 2023-05-04 11:29:08 +02:00 · 2023-05-04 11:26:11 +02:00 · 2023-05-04 10:07:05 +02:00
42 changed files with 6134 additions and 2055 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,7 +0,0 @@
-version: 2.1
-orbs:
-  node: circleci/node@3.0.0
-workflows:
-  node-tests:
-    jobs:
-      - node/test
--- a/.github/workflows/node.js.yml
+++ b/.github/workflows/node.js.yml
@@ -16,7 +16,7 @@ jobs:

    strategy:
      matrix:
-        node-version: [10.x, 12.x, 14.x]
+        node-version: [16.x, 18.x]

    steps:
    - uses: actions/checkout@v2
@@ -25,5 +25,7 @@ jobs:
      with:
        node-version: ${{ matrix.node-version }}
    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test
+    - run: npm run lint
+    - run: npm run test-extensive
+      env:
+        CI: true
--- a/.github/workflows/nodejs.yml
+++ b/.github/workflows/nodejs.yml
@@ -1,31 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [10.x, 12.x, 13.x]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    - run: npm run lint
-    - run: npm run test-extensive
-      env:
-        CI: true
--- a/INTERNALS.md
+++ b/INTERNALS.md
@@ -66,7 +66,7 @@ fields, respectively. These are used when peers concurrently insert at the same
 location in a document. Though quite rare in practice, Yjs needs to make sure
 the list items always resolve to the same order on all peers. The actual logic
 is relatively simple - its only a couple dozen lines of code and it lives in
-the `Item#integrate()` method. The YATA paper has much more detail on the this
+the `Item#integrate()` method. The YATA paper has much more detail on this
 algorithm.

 ### Item Storage
@@ -152,8 +152,8 @@ concepts that can be used to create a custom network protocol:
 an incremental document updates that allows clients to sync with each other.
 The update object is an Uint8Array that efficiently encodes `Item` objects and
 the delete set.
-* `state vector`: A state vector defines the know state of each user (a set of
-  tubles `(client, clock)`). This object is also efficiently encoded as a
+* `state vector`: A state vector defines the known state of each user (a set of
+  tuples `(client, clock)`). This object is also efficiently encoded as a
 Uint8Array.

 The client can ask a remote client for missing document updates by sending
@@ -168,7 +168,7 @@ An implementation of the syncing process is in
 ## Snapshots

 A snapshot can be used to restore an old document state. It is a `state vector`
-\+ `delete set`. I client can restore an old document state by iterating through
+\+ `delete set`. A client can restore an old document state by iterating through
 the sequence CRDT and ignoring all Items that have an `id.clock >
 stateVector[id.client].clock`. Instead of using `item.deleted` the client will
 use the delete set to find out if an item was deleted or not.
--- a/README.md
+++ b/README.md
@@ -15,58 +15,51 @@ suited for even large documents.

 * Demos: [https://github.com/yjs/yjs-demos](https://github.com/yjs/yjs-demos)
 * Discuss: [https://discuss.yjs.dev](https://discuss.yjs.dev)
+* Chat: [Gitter](https://gitter.im/Yjs/community) | [Discord](https://discord.gg/T3nqMT6qbM)
 * Benchmark Yjs vs. Automerge:
  [https://github.com/dmonad/crdt-benchmarks](https://github.com/dmonad/crdt-benchmarks)
 * Podcast [**"Yjs Deep Dive into real time collaborative editing solutions":**](https://www.tag1consulting.com/blog/deep-dive-real-time-collaborative-editing-solutions-tagteamtalk-001-0)
 * Podcast [**"Google Docs-style editing in Gutenberg with the YJS framework":**](https://publishpress.com/blog/yjs/)

-:construction_worker_woman: If you are looking for professional (paid) support to
-build collaborative or distributed applications ping us at
-<yjs@tag1consulting.com>. Otherwise you can find help on our
-[discussion board](https://discuss.yjs.dev).
+:construction_worker_woman: If you are looking for professional support, please
+consider supporting this project via a "support contract" on
+[GitHub Sponsors](https://github.com/sponsors/dmonad). I will attend your issues
+quicker and we can discuss questions and problems in regular video conferences.
+Otherwise you can find help on our community [discussion board](https://discuss.yjs.dev).

-## Sponsors
+## Sponsorship

-I'm currently looking for sponsors that allow me to be less dependent on
-contracting work. These awesome backers already fund further development of
-Yjs:
-
-[![davidhq](https://github.com/davidhq.png?size=60)](https://github.com/davidhq)
-[![Ifiok Jr.](https://github.com/ifiokjr.png?size=60)](https://github.com/ifiokjr)
-[![Burke Libbey](https://github.com/burke.png?size=60)](https://github.com/burke)
-[![Beni Cherniavsky-Paskin](https://github.com/cben.png?size=60)](https://github.com/cben)
-[![Tom Moor](https://github.com/tommoor.png?size=60)](https://github.com/tommoor)
-[![Michael Meyers](https://github.com/michaelemeyers.png?size=60)](https://github.com/michaelemeyers)
-[![Cristiano Benjamin](https://github.com/csbenjamin.png?size=60)](https://github.com/csbenjamin)
-[![Braden](https://github.com/AdventureBeard.png?size=60)](https://github.com/AdventureBeard)
-[![nimbuswebinc](https://nimbusweb.me/new-style-img/note-icon.svg)](https://github.com/nimbuswebinc)
-[![JourneyApps](https://github.com/journeyapps.png?size=60)](https://github.com/journeyapps)
-[![Adam Brunnmeier](https://github.com/adabru.png?size=60)](https://github.com/adabru)
-[![Nathanael Anderson](https://github.com/NathanaelA.png?size=60)](https://github.com/NathanaelA)
-[<img src="https://room.sh/img/icons/android-chrome-192x192.png" height="60px" />](https://room.sh/)
-
-Sponsorship also comes with special perks! [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=d42f2d)](https://github.com/sponsors/dmonad)
+Please contribute to the project financially - especially if your company relies
+on Yjs. [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=d42f2d)](https://github.com/sponsors/dmonad)

 ## Who is using Yjs

-* [Serenity Notes](https://www.serenity.re/en/notes) End-to-end encrypted
-  collaborative notes app.
+* [AFFiNE](https://affine.pro/) A local-first, privacy-first, open source
+  knowledge base. 🏅
+* [Dynaboard](https://dynaboard.com/) Build web apps collaboratively. :star2:
+* [Sana](https://sanalabs.com/) A learning platform with collaborative text
+  editing powered by Yjs.
 * [Relm](https://www.relm.us/) A collaborative gameworld for teamwork and
-  community. :star2:
-* [Input](https://input.com/) A collaborative note taking app. :star2:
+  community. :star:
 * [Room.sh](https://room.sh/) A meeting application with integrated
  collaborative drawing, editing, and coding tools. :star:
-* [https://coronavirustechhandbook.com/](https://coronavirustechhandbook.com/)
-  A collaborative wiki that is edited by thousands of different people to work
-  on a rapid and sophisticated response to the coronavirus outbreak and
-  subsequent impacts. :star:
 * [Nimbus Note](https://nimbusweb.me/note.php) A note-taking app designed by
-  Nimbus Web.
-* [JoeDocs](https://joedocs.com/) An open collaborative wiki.
-* [Pluxbox RadioManager](https://pluxbox.com/) A web-based app to
-  collaboratively organize radio broadcasts.
+  Nimbus Web. :star:
+* [Pluxbox RadioManager](https://getradiomanager.com/) A web-based app to
+  collaboratively organize radio broadcasts. :star:
+* [Serenity Notes](https://www.serenity.re/en/notes) End-to-end encrypted
+  collaborative notes app.
+* [PRSM](https://prsm.uk/) Collaborative mind-mapping and system visualisation. *[(source)](https://github.com/micrology/prsm)*
 * [Alldone](https://alldone.app/) A next-gen project management and
  collaboration platform.
+* [Living Spec](https://livingspec.com/) A modern way for product teams to collaborate.
+* [Slidebeamer](https://slidebeamer.com/) Presentation app.
+* [BlockSurvey](https://blocksurvey.io) End-to-end encryption for your forms/surveys.
+* [Skiff](https://skiff.org/) Private, decentralized workspace.
+* [Hyperquery](https://hyperquery.ai/) A collaborative data workspace for
+  sharing analyses, documentation, spreadsheets, and dashboards.
+* [Nosgestesclimat](https://nosgestesclimat.fr/groupe) The french carbon
+  footprint calculator has a group P2P mode based on yjs

 ## Table of Contents

@@ -99,7 +92,8 @@ are implemented in separate modules.
 | [Monaco](https://microsoft.github.io/monaco-editor/) | ✔ | [y-monaco](https://github.com/yjs/y-monaco) | [demo](https://demos.yjs.dev/monaco/monaco.html) |
 | [Slate](https://github.com/ianstormtaylor/slate) | ✔ | [slate-yjs](https://github.com/bitphinix/slate-yjs) | [demo](https://bitphinix.github.io/slate-yjs-example) |
 | [valtio](https://github.com/pmndrs/valtio) |  | [valtio-yjs](https://github.com/dai-shi/valtio-yjs) | [demo](https://codesandbox.io/s/valtio-yjs-demo-ox3iy) |
-| React / Vue / MobX | | [SyncedStore](https://syncedstore.org) | [demo](https://syncedstore.org/docs/react) |
+| [immer](https://github.com/immerjs/immer) |  | [immer-yjs](https://github.com/sep2/immer-yjs) | [demo](https://codesandbox.io/s/immer-yjs-demo-6e0znb) |
+| React / Vue / Svelte / MobX | | [SyncedStore](https://syncedstore.org) | [demo](https://syncedstore.org/docs/react) |

 ### Providers

@@ -141,6 +135,20 @@ Also includes a peer-sync mechanism to catch up on missed updates.
 <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>
+  <dt><a href="https://github.com/yousefED/matrix-crdt">Matrix-CRDT</a></dt>
+  <dd>
+Use <a href="https://www.matrix.org">Matrix</a> as an off-the-shelf backend for
+Yjs by using the <a href="https://github.com/yousefED/matrix-crdt">MatrixProvider</a>.
+Use Matrix as transport and storage of Yjs updates, so you can focus building
+your client app and Matrix can provide powerful features like Authentication,
+Authorization, Federation, hosting (self-hosting or SaaS) and even End-to-End
+Encryption (E2EE).
+</dd>
+  <dt><a href="https://github.com/MaxNoetzold/y-mongodb-provider">y-mongodb-provider</a></dt>
+  <dd>
+Adds persistent storage to a server with MongoDB. Can be used with the
+y-websocket provider.
 </dd>
 </dl>

@@ -161,6 +169,9 @@ PORT=1234 node ./node_modules/y-websocket/bin/server.js
 ### Example: Observe types

 ```js
+import * as Y from 'yjs';
+
+const doc = new Y.Doc();
 const yarray = doc.getArray('my-array')
 yarray.observe(event => {
  console.log('yarray was modified')
@@ -634,6 +645,8 @@ type. Doesn't log types that have not been defined (using
  <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>getText(string):Y.Text</code></b>
+  <dd>Define a shared Y.Text type. Is equivalent to <code>y.get(string, Y.Text)</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>
@@ -743,6 +756,30 @@ currentState1 = Y.mergeUpdates([currentState1, diff2])
 currentState1 = Y.mergeUpdates([currentState1, diff1])
 ```

+#### Obfuscating Updates
+
+If one of your users runs into a weird bug (e.g. the rich-text editor throws
+error messages), then you don't have to request the full document from your
+user. Instead, they can obfuscate the document (i.e. replace the content with
+meaningless generated content) before sending it to you. Note that someone might
+still deduce the type of content by looking at the general structure of the
+document. But this is much better than requesting the original document.
+
+Obfuscated updates contain all the CRDT-related data that is required for
+merging. So it is safe to merge obfuscated updates.
+
+```javascript
+const ydoc = new Y.Doc()
+// perform some changes..
+ydoc.getText().insert(0, 'hello world')
+const update = Y.encodeStateAsUpdate(ydoc)
+// the below update contains scrambled data
+const obfuscatedUpdate = Y.obfuscateUpdate(update)
+const ydoc2 = new Y.Doc()
+Y.applyUpdate(ydoc2, obfuscatedUpdate)
+ydoc2.getText().toString() // => "00000000000"
+```
+
 #### Using V2 update format

 Yjs implements two update formats. By default you are using the V1 update format.
@@ -798,6 +835,21 @@ Convert V2 update format to the V1 update format.

 ### Relative Positions

+When working with collaborative documents, we often need to work with positions.
+Positions may represent cursor locations, selection ranges, or even assign a
+comment to a range of text. Normal index-positions (expressed as integers) are
+not convenient to use because the index-range is invalidated as soon as a remote
+change manipulates the document. Relative positions give you a powerful API to
+express positions.
+
+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
@@ -832,14 +884,35 @@ 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.createRelativePositionFromTypeIndex(type:Uint8Array|Y.Type, index: number
+[, assoc=0])
+  </code></b>
+  <dd>
+Create a relative position fixated to the i-th element in any sequence-like
+shared type (if <code>assoc >= 0</code>). By default, the position associates
+with the character that comes after the specified index position. If
+<code>assoc < 0</code>, then the relative position associates with the character
+before the specified index position.
+  </dd>
+  <b><code>
+Y.createAbsolutePositionFromRelativePosition(RelativePosition, Y.Doc):
+{ type: Y.AbstractType, index: number, assoc: number } | null
+  </code></b>
+  <dd>
+Create an absolute position from a relative position. If the relative position
+cannot be referenced, or the type is deleted, then the result is null.
+  </dd>
+  <b><code>
+Y.encodeRelativePosition(RelativePosition):Uint8Array
+  </code></b>
+  <dd>
+Encode a relative position to an Uint8Array. Binary data is the preferred
+encoding format for document updates. If you prefer JSON encoding, you can
+simply JSON.stringify / JSON.parse the relative position instead.
+  </dd>
  <b><code>Y.decodeRelativePosition(Uint8Array):RelativePosition</code></b>
-  <dd></dd>
+  <dd>Decode a binary-encoded relative position to a RelativePositon object.</dd>
 </dl>

 ### Y.UndoManager
@@ -880,6 +953,16 @@ undo- or the redo-stack.
  </dd>
  <b>
    <code>
+on('stack-item-updated', { stackItem: { meta: Map&lt;any,any&gt; }, type: 'undo'
+| 'redo' })
+    </code>
+  </b>
+  <dd>
+Register an event that is called when an existing <code>StackItem</code> is updated.
+This happens when two changes happen within a "captureInterval".
+  </dd>
+  <b>
+    <code>
 on('stack-item-popped', { stackItem: { meta: Map&lt;any,any&gt; }, type: 'undo'
 | 'redo' })
    </code>
@@ -888,6 +971,14 @@ on('stack-item-popped', { stackItem: { meta: Map&lt;any,any&gt; }, type: 'undo'
 Register an event that is called when a <code>StackItem</code> is popped from
 the undo- or the redo-stack.
  </dd>
+  <b>
+    <code>
+on('stack-cleared', { undoStackCleared: boolean, redoStackCleared: boolean })
+    </code>
+  </b>
+  <dd>
+Register an event that is called when the undo- and/or the redo-stack is cleared.
+  </dd>
 </dl>

 #### Example: Stop Capturing
@@ -980,7 +1071,7 @@ undoManager.on('stack-item-popped', event => {

 *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
+differentiation 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
@@ -999,16 +1090,17 @@ More information about the specific implementation is available in
 [INTERNALS.md](./INTERNALS.md) and in
 [this walkthrough of the Yjs codebase](https://youtu.be/0l5XgnQ6rB4).

-CRDTs that 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).
+CRDTs that are 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:**

--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "yjs",
-  "version": "13.5.23",
+  "version": "13.6.2",
  "description": "Shared Editing Library",
  "main": "./dist/yjs.cjs",
  "module": "./dist/yjs.mjs",
@@ -22,11 +22,12 @@
    "preversion": "npm run lint && PRODUCTION=1 npm run dist && npm run docs && node ./dist/tests.cjs --repetition-time 1000 && test -e dist/src/index.d.ts && test -e dist/yjs.cjs && test -e dist/yjs.cjs",
    "debug": "concurrently 'http-server -o test.html' 'npm run watch'",
    "trace-deopt": "clear && rollup -c  && node --trace-deopt dist/test.cjs",
-    "trace-opt": "clear && rollup -c  && node --trace-opt dist/test.cjs",
-    "postinstall": "node ./sponsor-y.js"
+    "trace-opt": "clear && rollup -c  && node --trace-opt dist/test.cjs"
  },
  "exports": {
    ".": {
+      "types": "./dist/src/index.d.ts",
+      "module": "./dist/yjs.mjs",
      "import": "./dist/yjs.mjs",
      "require": "./dist/yjs.cjs"
    },
@@ -74,19 +75,24 @@
  },
  "homepage": "https://docs.yjs.dev",
  "dependencies": {
-    "lib0": "^0.2.43"
+    "lib0": "^0.2.74"
  },
  "devDependencies": {
-    "@rollup/plugin-commonjs": "^17.0.0",
-    "@rollup/plugin-node-resolve": "^11.2.1",
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@types/node": "^18.15.5",
    "concurrently": "^3.6.1",
    "http-server": "^0.12.3",
    "jsdoc": "^3.6.7",
    "markdownlint-cli": "^0.23.2",
-    "rollup": "^2.60.0",
+    "rollup": "^3.20.0",
    "standard": "^16.0.4",
    "tui-jsdoc-template": "^1.2.2",
-    "typescript": "^4.4.4",
+    "typescript": "^4.9.5",
    "y-protocols": "^1.0.5"
+  },
+  "engines": {
+    "npm": ">=8.0.0",
+    "node": ">=16.0.0"
  }
 }
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -42,13 +42,7 @@ export default [{
    name: 'Y',
    file: 'dist/yjs.cjs',
    format: 'cjs',
-    sourcemap: true,
-    paths: path => {
-      if (/^lib0\//.test(path)) {
-        return `lib0/dist/${path.slice(5)}.cjs`
-      }
-      return path
-    }
+    sourcemap: true
  },
  external: id => /^lib0\//.test(id)
 }, {
@@ -88,7 +82,7 @@ export default [{
  plugins: [
    debugResolve,
    nodeResolve({
-      mainFields: ['module', 'browser', 'main']
+      mainFields: ['browser', 'module', 'main']
    }),
    commonjs()
  ]
@@ -103,9 +97,10 @@ export default [{
  plugins: [
    debugResolve,
    nodeResolve({
-      mainFields: ['module', 'main']
+      mainFields: ['node', 'module', 'main'],
+      exportConditions: ['node', 'module', 'import', 'default']
    }),
    commonjs()
  ],
-  external: ['isomorphic.js']
+  external: id => /^lib0\//.test(id)
 }]
--- a/sponsor-y.js
+++ b/sponsor-y.js
@@ -1,12 +0,0 @@
-
-try {
-  const log = require('lib0/dist/logging.cjs')
-
-  log.print()
-  log.print(log.BOLD, log.GREEN, log.BOLD, 'Thank you for using Yjs ', log.RED, '❤\n')
-  log.print(
-    log.GREY,
-    'The project has grown considerably in the past year. Too much for me to maintain\nin my spare time. Several companies built their products with Yjs.\nYet, this project receives very little funding. Yjs is far from done. I want to\ncreate more awesome extensions and work on the growing number of open issues.\n', log.BOLD, 'Dear user, the future of this project entirely depends on you.\n')
-  log.print(log.BLUE, log.BOLD, 'Please start funding the project now: https://github.com/sponsors/dmonad \n')
-  log.print(log.GREY, '(This message will be removed when I achieved my funding goal)\n\n')
-} catch (e) { }
--- a/src/index.js
+++ b/src/index.js
@@ -67,6 +67,8 @@ export {
  decodeStateVector,
  logUpdate,
  logUpdateV2,
+  decodeUpdate,
+  decodeUpdateV2,
  relativePositionToJSON,
  isDeleted,
  isParentOf,
@@ -87,21 +89,28 @@ export {
  diffUpdate,
  diffUpdateV2,
  convertUpdateFormatV1ToV2,
-  convertUpdateFormatV2ToV1
+  convertUpdateFormatV2ToV1,
+  obfuscateUpdate,
+  obfuscateUpdateV2,
+  UpdateEncoderV1,
+  equalDeleteSets,
+  snapshotContainsUpdate
 } from './internals.js'

-const glo = /** @type {any} */ (typeof window !== 'undefined'
-  ? window
-  // @ts-ignore
-  : typeof global !== 'undefined' ? global : {})
+const glo = /** @type {any} */ (typeof globalThis !== 'undefined'
+  ? globalThis
+  : typeof window !== 'undefined'
+    ? window
+    // @ts-ignore
+    : typeof global !== 'undefined' ? global : {})

 const importIdentifier = '__ $YJS$ __'

 if (glo[importIdentifier] === true) {
  /**
-   * Dear reader of this warning message. Please take this seriously.
+   * Dear reader of this message. Please take this seriously.
   *
-   * If you see this message, please make sure that you only import one version of Yjs. In many cases,
+   * If you see this message, make sure that you only import one version of Yjs. In many cases,
   * your package manager installs two versions of Yjs that are used by different packages within your project.
   * Another reason for this message is that some parts of your project use the commonjs version of Yjs
   * and others use the EcmaScript version of Yjs.
@@ -109,7 +118,9 @@ if (glo[importIdentifier] === true) {
   * This often leads to issues that are hard to debug. We often need to perform constructor checks,
   * e.g. `struct instanceof GC`. If you imported different versions of Yjs, it is impossible for us to
   * do the constructor checks anymore - which might break the CRDT algorithm.
+   *
+   * https://github.com/yjs/yjs/issues/438
   */
-  console.warn('Yjs was already imported. Importing different versions of Yjs often leads to issues.')
+  console.error('Yjs was already imported. This breaks constructor checks and will lead to issues! - https://github.com/yjs/yjs/issues/438')
 }
 glo[importIdentifier] = true
--- a/src/structs/ContentFormat.js
+++ b/src/structs/ContentFormat.js
@@ -100,4 +100,4 @@ export class ContentFormat {
 * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
 * @return {ContentFormat}
 */
-export const readContentFormat = decoder => new ContentFormat(decoder.readString(), decoder.readJSON())
+export const readContentFormat = decoder => new ContentFormat(decoder.readKey(), decoder.readJSON())
--- a/src/structs/ContentType.js
+++ b/src/structs/ContentType.js
@@ -39,7 +39,7 @@ export const YXmlTextRefID = 6
 */
 export class ContentType {
  /**
-   * @param {AbstractType<YEvent>} type
+   * @param {AbstractType<any>} type
   */
  constructor (type) {
    /**
@@ -109,7 +109,7 @@ export class ContentType {
      if (!item.deleted) {
        item.delete(transaction)
      } else {
-        // Whis will be gc'd later and we want to merge it if possible
+        // This will be gc'd later and we want to merge it if possible
        // We try to merge all deleted items after each transaction,
        // but we have no knowledge about that this needs to be merged
        // since it is not in transaction.ds. Hence we add it to transaction._mergeStructs
--- a/src/structs/Item.js
+++ b/src/structs/Item.js
@@ -22,11 +22,13 @@ import {
  readContentFormat,
  readContentType,
  addChangedTypeToTransaction,
-  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, ContentType, ContentDeleted, StructStore, ID, AbstractType, Transaction // eslint-disable-line
+  isDeleted,
+  StackItem, DeleteSet, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, ContentType, ContentDeleted, StructStore, ID, AbstractType, Transaction // eslint-disable-line
 } from '../internals.js'

 import * as error from 'lib0/error'
 import * as binary from 'lib0/binary'
+import * as array from 'lib0/array'

 /**
 * @todo This should return several items
@@ -119,19 +121,27 @@ export const splitItem = (transaction, leftItem, diff) => {
  return rightItem
 }

+/**
+ * @param {Array<StackItem>} stack
+ * @param {ID} id
+ */
+const isDeletedByUndoStack = (stack, id) => array.some(stack, /** @param {StackItem} s */ s => isDeleted(s.deletions, id))
+
 /**
 * Redoes the effect of this operation.
 *
 * @param {Transaction} transaction The Yjs instance.
 * @param {Item} item
 * @param {Set<Item>} redoitems
- * @param {Array<Item>} itemsToDelete
+ * @param {DeleteSet} itemsToDelete
+ * @param {boolean} ignoreRemoteMapChanges
+ * @param {import('../utils/UndoManager.js').UndoManager} um
 *
 * @return {Item|null}
 *
 * @private
 */
-export const redoItem = (transaction, item, redoitems, itemsToDelete) => {
+export const redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) => {
  const doc = transaction.doc
  const store = doc.store
  const ownClientID = doc.clientID
@@ -143,42 +153,27 @@ export const redoItem = (transaction, item, redoitems, itemsToDelete) => {
  /**
   * @type {Item|null}
   */
-  let left
+  let left = null
  /**
   * @type {Item|null}
   */
  let right
+  // make sure that parent is redone
+  if (parentItem !== null && parentItem.deleted === true) {
+    // try to undo parent if it will be undone anyway
+    if (parentItem.redone === null && (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) === null)) {
+      return null
+    }
+    while (parentItem.redone !== null) {
+      parentItem = getItemCleanStart(transaction, parentItem.redone)
+    }
+  }
+  const parentType = parentItem === null ? /** @type {AbstractType<any>} */ (item.parent) : /** @type {ContentType} */ (parentItem.content).type
+
  if (item.parentSub === null) {
    // Is an array item. Insert at the old position
    left = item.left
    right = item
-  } else {
-    // Is a map item. Insert as current value
-    left = item
-    while (left.right !== null) {
-      left = left.right
-      if (left.id.client !== ownClientID) {
-        // It is not possible to redo this item because it conflicts with a
-        // change from another client
-        return null
-      }
-    }
-    if (left.right !== null) {
-      left = /** @type {Item} */ (/** @type {AbstractType<any>} */ (item.parent)._map.get(item.parentSub))
-    }
-    right = null
-  }
-  // make sure that parent is redone
-  if (parentItem !== null && parentItem.deleted === true && parentItem.redone === null) {
-    // try to undo parent if it will be undone anyway
-    if (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete) === 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) {
      /**
@@ -210,10 +205,24 @@ export const redoItem = (transaction, item, redoitems, itemsToDelete) => {
      }
      right = right.right
    }
-    // Iterate right while right is in itemsToDelete
-    // If it is intended to delete right while item is redone, we can expect that item should replace right.
-    while (left !== null && left.right !== null && left.right !== right && itemsToDelete.findIndex(d => d === /** @type {Item} */ (left).right) >= 0) {
-      left = left.right
+  } else {
+    right = null
+    if (item.right && !ignoreRemoteMapChanges) {
+      left = item
+      // Iterate right while right is in itemsToDelete
+      // If it is intended to delete right while item is redone, we can expect that item should replace right.
+      while (left !== null && left.right !== null && (left.right.redone || isDeleted(itemsToDelete, left.right.id) || isDeletedByUndoStack(um.undoStack, left.right.id) || isDeletedByUndoStack(um.redoStack, left.right.id))) {
+        left = left.right
+        // follow redone
+        while (left.redone) left = getItemCleanStart(transaction, left.redone)
+      }
+      if (left && left.right !== null) {
+        // It is not possible to redo this item because it conflicts with a
+        // change from another client
+        return null
+      }
+    } else {
+      left = parentType._map.get(item.parentSub) || null
    }
  }
  const nextClock = getState(store, ownClientID)
@@ -222,7 +231,7 @@ export const redoItem = (transaction, item, redoitems, itemsToDelete) => {
    nextId,
    left, left && left.lastId,
    right, right && right.id,
-    parentItem === null ? item.parent : /** @type {ContentType} */ (parentItem.content).type,
+    parentType,
    item.parentSub,
    item.content.copy()
  )
@@ -281,7 +290,7 @@ export class Item extends AbstractStruct {
     */
    this.parentSub = parentSub
    /**
-     * If this type's effect is reundone this type refers to the type that undid
+     * If this type's effect is redone this type refers to the type that undid
     * this operation.
     * @type {ID | null}
     */
@@ -752,48 +761,48 @@ export class AbstractContent {
  }

  /**
-   * @param {number} offset
+   * @param {number} _offset
   * @return {AbstractContent}
   */
-  splice (offset) {
+  splice (_offset) {
    throw error.methodUnimplemented()
  }

  /**
-   * @param {AbstractContent} right
+   * @param {AbstractContent} _right
   * @return {boolean}
   */
-  mergeWith (right) {
+  mergeWith (_right) {
    throw error.methodUnimplemented()
  }

  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
+   * @param {Transaction} _transaction
+   * @param {Item} _item
   */
-  integrate (transaction, item) {
+  integrate (_transaction, _item) {
    throw error.methodUnimplemented()
  }

  /**
-   * @param {Transaction} transaction
+   * @param {Transaction} _transaction
   */
-  delete (transaction) {
+  delete (_transaction) {
    throw error.methodUnimplemented()
  }

  /**
-   * @param {StructStore} store
+   * @param {StructStore} _store
   */
-  gc (store) {
+  gc (_store) {
    throw error.methodUnimplemented()
  }

  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   * @param {number} offset
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} _encoder
+   * @param {number} _offset
   */
-  write (encoder, offset) {
+  write (_encoder, _offset) {
    throw error.methodUnimplemented()
  }

--- a/src/types/AbstractType.js
+++ b/src/types/AbstractType.js
@@ -278,7 +278,7 @@ export class AbstractType {
    this._eH = createEventHandler()
    /**
     * Deep event handlers
-     * @type {EventHandler<Array<YEvent>,Transaction>}
+     * @type {EventHandler<Array<YEvent<any>>,Transaction>}
     */
    this._dEH = createEventHandler()
    /**
@@ -324,9 +324,9 @@ export class AbstractType {
  }

  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} _encoder
   */
-  _write (encoder) { }
+  _write (_encoder) { }

  /**
   * The first non-deleted item
@@ -344,9 +344,9 @@ export class AbstractType {
   * Must be implemented by each type.
   *
   * @param {Transaction} transaction
-   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
+   * @param {Set<null|string>} _parentSubs Keys changed on this type. `null` if list was modified.
   */
-  _callObserver (transaction, parentSubs) {
+  _callObserver (transaction, _parentSubs) {
    if (!transaction.local && this._searchMarker) {
      this._searchMarker.length = 0
    }
@@ -364,7 +364,7 @@ export class AbstractType {
  /**
   * Observe all events that are created by this type and its children.
   *
-   * @param {function(Array<YEvent>,Transaction):void} f Observer function
+   * @param {function(Array<YEvent<any>>,Transaction):void} f Observer function
   */
  observeDeep (f) {
    addEventHandlerListener(this._dEH, f)
@@ -382,7 +382,7 @@ export class AbstractType {
  /**
   * Unregister an observer function.
   *
-   * @param {function(Array<YEvent>,Transaction):void} f Observer function
+   * @param {function(Array<YEvent<any>>,Transaction):void} f Observer function
   */
  unobserveDeep (f) {
    removeEventHandlerListener(this._dEH, f)
@@ -735,6 +735,29 @@ export const typeListInsertGenerics = (transaction, parent, index, content) => {
  return typeListInsertGenericsAfter(transaction, parent, n, content)
 }

+/**
+ * Pushing content is special as we generally want to push after the last item. So we don't have to update
+ * the serach marker.
+ *
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {Array<Object<string,any>|Array<any>|number|null|string|Uint8Array>} content
+ *
+ * @private
+ * @function
+ */
+export const typeListPushGenerics = (transaction, parent, content) => {
+  // Use the marker with the highest index and iterate to the right.
+  const marker = (parent._searchMarker || []).reduce((maxMarker, currMarker) => currMarker.index > maxMarker.index ? currMarker : maxMarker, { index: 0, p: parent._start })
+  let n = marker.p
+  if (n) {
+    while (n.right) {
+      n = n.right
+    }
+  }
+  return typeListInsertGenericsAfter(transaction, parent, n, content)
+}
+
 /**
 * @param {Transaction} transaction
 * @param {AbstractType<any>} parent
--- a/src/types/YArray.js
+++ b/src/types/YArray.js
@@ -10,6 +10,7 @@ import {
  typeListForEach,
  typeListCreateIterator,
  typeListInsertGenerics,
+  typeListPushGenerics,
  typeListDelete,
  typeListMap,
  YArrayRefID,
@@ -22,6 +23,7 @@ import { typeListSlice } from './AbstractType.js'
 /**
 * Event that describes the changes on a YArray
 * @template T
+ * @extends YEvent<YArray<T>>
 */
 export class YArrayEvent extends YEvent {
  /**
@@ -56,11 +58,14 @@ export class YArray extends AbstractType {

  /**
   * Construct a new YArray containing the specified items.
-   * @template T
+   * @template {Object<string,any>|Array<any>|number|null|string|Uint8Array} T
   * @param {Array<T>} items
   * @return {YArray<T>}
   */
  static from (items) {
+    /**
+     * @type {YArray<T>}
+     */
    const a = new YArray()
    a.push(items)
    return a
@@ -82,6 +87,9 @@ export class YArray extends AbstractType {
    this._prelimContent = null
  }

+  /**
+   * @return {YArray<T>}
+   */
  _copy () {
    return new YArray()
  }
@@ -90,9 +98,12 @@ export class YArray extends AbstractType {
   * @return {YArray<T>}
   */
  clone () {
+    /**
+     * @type {YArray<T>}
+     */
    const arr = new YArray()
    arr.insert(0, this.toArray().map(el =>
-      el instanceof AbstractType ? el.clone() : el
+      el instanceof AbstractType ? /** @type {typeof el} */ (el.clone()) : el
    ))
    return arr
  }
@@ -131,7 +142,7 @@ export class YArray extends AbstractType {
  insert (index, content) {
    if (this.doc !== null) {
      transact(this.doc, transaction => {
-        typeListInsertGenerics(transaction, this, index, content)
+        typeListInsertGenerics(transaction, this, index, /** @type {any} */ (content))
      })
    } else {
      /** @type {Array<any>} */ (this._prelimContent).splice(index, 0, ...content)
@@ -142,9 +153,17 @@ export class YArray extends AbstractType {
   * Appends content to this YArray.
   *
   * @param {Array<T>} content Array of content to append.
+   *
+   * @todo Use the following implementation in all types.
   */
  push (content) {
-    this.insert(this.length, content)
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeListPushGenerics(transaction, this, /** @type {any} */ (content))
+      })
+    } else {
+      /** @type {Array<any>} */ (this._prelimContent).push(...content)
+    }
  }

  /**
@@ -225,7 +244,7 @@ export class YArray extends AbstractType {
  }

  /**
-   * Executes a provided function on once on overy element of this YArray.
+   * Executes a provided function once on overy element of this YArray.
   *
   * @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.
   */
@@ -249,9 +268,9 @@ export class YArray extends AbstractType {
 }

 /**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder
 *
 * @private
 * @function
 */
-export const readYArray = decoder => new YArray()
+export const readYArray = _decoder => new YArray()
--- a/src/types/YMap.js
+++ b/src/types/YMap.js
@@ -21,6 +21,7 @@ import * as iterator from 'lib0/iterator'

 /**
 * @template T
+ * @extends YEvent<YMap<T>>
 * Event that describes the changes on a YMap.
 */
 export class YMapEvent extends YEvent {
@@ -80,6 +81,9 @@ export class YMap extends AbstractType {
    this._prelimContent = null
  }

+  /**
+   * @return {YMap<MapType>}
+   */
  _copy () {
    return new YMap()
  }
@@ -88,9 +92,12 @@ export class YMap extends AbstractType {
   * @return {YMap<MapType>}
   */
  clone () {
+    /**
+     * @type {YMap<MapType>}
+     */
    const map = new YMap()
    this.forEach((value, key) => {
-      map.set(key, value instanceof AbstractType ? value.clone() : value)
+      map.set(key, value instanceof AbstractType ? /** @type {typeof value} */ (value.clone()) : value)
    })
    return map
  }
@@ -166,20 +173,17 @@ export class YMap extends AbstractType {
   * @param {function(MapType,string,YMap<MapType>):void} f A function to execute on every element of this YArray.
   */
  forEach (f) {
-    /**
-     * @type {Object<string,MapType>}
-     */
-    const map = {}
    this._map.forEach((item, key) => {
      if (!item.deleted) {
        f(item.content.getContent()[item.length - 1], key, this)
      }
    })
-    return map
  }

  /**
-   * @return {IterableIterator<MapType>}
+   * Returns an Iterator of [key, value] pairs
+   *
+   * @return {IterableIterator<any>}
   */
  [Symbol.iterator] () {
    return this.entries()
@@ -202,14 +206,16 @@ export class YMap extends AbstractType {

  /**
   * Adds or updates an element with a specified key and value.
+   * @template {MapType} VAL
   *
   * @param {string} key The key of the element to add to this YMap
-   * @param {MapType} value The value of the element to add
+   * @param {VAL} value The value of the element to add
+   * @return {VAL}
   */
  set (key, value) {
    if (this.doc !== null) {
      transact(this.doc, transaction => {
-        typeMapSet(transaction, this, key, value)
+        typeMapSet(transaction, this, key, /** @type {any} */ (value))
      })
    } else {
      /** @type {Map<string, any>} */ (this._prelimContent).set(key, value)
@@ -243,7 +249,7 @@ export class YMap extends AbstractType {
  clear () {
    if (this.doc !== null) {
      transact(this.doc, transaction => {
-        this.forEach(function (value, key, map) {
+        this.forEach(function (_value, key, map) {
          typeMapDelete(transaction, map, key)
        })
      })
@@ -261,9 +267,9 @@ export class YMap extends AbstractType {
 }

 /**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder
 *
 * @private
 * @function
 */
-export const readYMap = decoder => new YMap()
+export const readYMap = _decoder => new YMap()
--- a/src/types/YText.js
+++ b/src/types/YText.js
@@ -251,7 +251,7 @@ const insertAttributes = (transaction, parent, currPos, attributes) => {
 * @function
 **/
 const insertText = (transaction, parent, currPos, text, attributes) => {
-  currPos.currentAttributes.forEach((val, key) => {
+  currPos.currentAttributes.forEach((_val, key) => {
    if (attributes[key] === undefined) {
      attributes[key] = null
    }
@@ -291,7 +291,17 @@ const formatText = (transaction, parent, currPos, length, attributes) => {
  const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes)
  // iterate until first non-format or null is found
  // delete all formats with attributes[format.key] != null
-  while (length > 0 && currPos.right !== null) {
+  // also check the attributes after the first non-format as we do not want to insert redundant negated attributes there
+  // eslint-disable-next-line no-labels
+  iterationLoop: while (
+    currPos.right !== null &&
+    (length > 0 ||
+      (
+        negatedAttributes.size > 0 &&
+        (currPos.right.deleted || currPos.right.content.constructor === ContentFormat)
+      )
+    )
+  ) {
    if (!currPos.right.deleted) {
      switch (currPos.right.content.constructor) {
        case ContentFormat: {
@@ -301,9 +311,16 @@ const formatText = (transaction, parent, currPos, length, attributes) => {
            if (equalAttrs(attr, value)) {
              negatedAttributes.delete(key)
            } else {
+              if (length === 0) {
+                // no need to further extend negatedAttributes
+                // eslint-disable-next-line no-labels
+                break iterationLoop
+              }
              negatedAttributes.set(key, value)
            }
            currPos.right.delete(transaction)
+          } else {
+            currPos.currentAttributes.set(key, value)
          }
          break
        }
@@ -338,31 +355,55 @@ const formatText = (transaction, parent, currPos, length, attributes) => {
 *
 * @param {Transaction} transaction
 * @param {Item} start
- * @param {Item|null} end exclusive end, automatically iterates to the next Content Item
+ * @param {Item|null} curr exclusive end, automatically iterates to the next Content Item
 * @param {Map<string,any>} startAttributes
- * @param {Map<string,any>} endAttributes This attribute is modified!
+ * @param {Map<string,any>} currAttributes
 * @return {number} The amount of formatting Items deleted.
 *
 * @function
 */
-const cleanupFormattingGap = (transaction, start, end, startAttributes, endAttributes) => {
+const cleanupFormattingGap = (transaction, start, curr, startAttributes, currAttributes) => {
+  /**
+   * @type {Item|null}
+   */
+  let end = start
+  /**
+   * @type {Map<string,ContentFormat>}
+   */
+  const endFormats = map.create()
  while (end && (!end.countable || end.deleted)) {
    if (!end.deleted && end.content.constructor === ContentFormat) {
-      updateCurrentAttributes(endAttributes, /** @type {ContentFormat} */ (end.content))
+      const cf = /** @type {ContentFormat} */ (end.content)
+      endFormats.set(cf.key, cf)
    }
    end = end.right
  }
  let cleanups = 0
+  let reachedCurr = false
  while (start !== end) {
+    if (curr === start) {
+      reachedCurr = true
+    }
    if (!start.deleted) {
      const content = start.content
      switch (content.constructor) {
        case ContentFormat: {
          const { key, value } = /** @type {ContentFormat} */ (content)
-          if ((endAttributes.get(key) || null) !== value || (startAttributes.get(key) || null) === value) {
+          const startAttrValue = startAttributes.get(key) || null
+          if (endFormats.get(key) !== content || startAttrValue === value) {
            // Either this format is overwritten or it is not necessary because the attribute already existed.
            start.delete(transaction)
            cleanups++
+            if (!reachedCurr && (currAttributes.get(key) || null) === value && startAttrValue !== value) {
+              if (startAttrValue === null) {
+                currAttributes.delete(key)
+              } else {
+                currAttributes.set(key, startAttrValue)
+              }
+            }
+          }
+          if (!reachedCurr && !start.deleted) {
+            updateCurrentAttributes(currAttributes, /** @type {ContentFormat} */ (content))
          }
          break
        }
@@ -465,7 +506,7 @@ const deleteText = (transaction, currPos, length) => {
    currPos.forward()
  }
  if (start) {
-    cleanupFormattingGap(transaction, start, currPos.right, startAttrs, map.copy(currPos.currentAttributes))
+    cleanupFormattingGap(transaction, start, currPos.right, startAttrs, currPos.currentAttributes)
  }
  const parent = /** @type {AbstractType<any>} */ (/** @type {Item} */ (currPos.left || currPos.right).parent)
  if (parent._searchMarker) {
@@ -502,6 +543,7 @@ const deleteText = (transaction, currPos, length) => {
  */

 /**
+ * @extends YEvent<YText>
 * Event that describes the changes on a YText type.
 */
 export class YTextEvent extends YEvent {
@@ -589,36 +631,39 @@ export class YTextEvent extends YEvent {
            /**
             * @type {any}
             */
-            let op
+            let op = null
            switch (action) {
              case 'delete':
-                op = { delete: deleteLen }
+                if (deleteLen > 0) {
+                  op = { delete: deleteLen }
+                }
                deleteLen = 0
                break
              case 'insert':
-                op = { insert }
-                if (currentAttributes.size > 0) {
-                  op.attributes = {}
-                  currentAttributes.forEach((value, key) => {
-                    if (value !== null) {
-                      op.attributes[key] = value
-                    }
-                  })
+                if (typeof insert === 'object' || insert.length > 0) {
+                  op = { insert }
+                  if (currentAttributes.size > 0) {
+                    op.attributes = {}
+                    currentAttributes.forEach((value, key) => {
+                      if (value !== null) {
+                        op.attributes[key] = value
+                      }
+                    })
+                  }
                }
                insert = ''
                break
              case 'retain':
-                op = { retain }
-                if (Object.keys(attributes).length > 0) {
-                  op.attributes = {}
-                  for (const key in attributes) {
-                    op.attributes[key] = attributes[key]
+                if (retain > 0) {
+                  op = { retain }
+                  if (!object.isEmpty(attributes)) {
+                    op.attributes = object.assign({}, attributes)
                  }
                }
                retain = 0
                break
            }
-            delta.push(op)
+            if (op) delta.push(op)
            action = null
          }
        }
@@ -684,7 +729,7 @@ export class YTextEvent extends YEvent {
                    } else {
                      attributes[key] = value
                    }
-                  } else {
+                  } else if (value !== null) {
                    item.delete(transaction)
                  }
                }
@@ -710,7 +755,7 @@ export class YTextEvent extends YEvent {
                    } else {
                      attributes[key] = value
                    }
-                  } else {
+                  } else if (attr !== null) { // this will be cleaned up automatically by the contextless cleanup function
                    item.delete(transaction)
                  }
                }
@@ -900,7 +945,7 @@ export class YText extends AbstractType {
   * Apply a {@link Delta} on this shared YText type.
   *
   * @param {any} delta The changes to apply on this element.
-   * @param {object}  [opts]
+   * @param {object}  opts
   * @param {boolean} [opts.sanitize] Sanitize input delta. Removes ending newlines if set to true.
   *
   *
@@ -976,27 +1021,19 @@ export class YText extends AbstractType {
        str = ''
      }
    }
-    // 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)
-      }
-      if (prevSnapshot) {
-        splitSnapshotAffectedStructs(transaction, prevSnapshot)
-      }
+    const computeDelta = () => {
      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') {
+                if (cur === undefined || cur.user !== n.id.client || cur.type !== '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') {
+                if (cur === undefined || cur.user !== n.id.client || cur.type !== 'added') {
                  packStr()
                  currentAttributes.set('ychange', computeYChange ? computeYChange('added', n.id) : { type: 'added' })
                }
@@ -1037,7 +1074,22 @@ export class YText extends AbstractType {
        n = n.right
      }
      packStr()
-    }, splitSnapshotAffectedStructs)
+    }
+    if (snapshot || prevSnapshot) {
+      // snapshots are merged again after the transaction, so we need to keep the
+      // transaction alive until we are done
+      transact(doc, transaction => {
+        if (snapshot) {
+          splitSnapshotAffectedStructs(transaction, snapshot)
+        }
+        if (prevSnapshot) {
+          splitSnapshotAffectedStructs(transaction, prevSnapshot)
+        }
+        computeDelta()
+      }, 'cleanup')
+    } else {
+      computeDelta()
+    }
    return ops
  }

@@ -1202,12 +1254,11 @@ export class YText extends AbstractType {
   *
   * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
   *
-   * @param {Snapshot} [snapshot]
   * @return {Object<string, any>} A JSON Object that describes the attributes.
   *
   * @public
   */
-  getAttributes (snapshot) {
+  getAttributes () {
    return typeMapGetAll(this)
  }

@@ -1220,10 +1271,10 @@ export class YText extends AbstractType {
 }

 /**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder
 * @return {YText}
 *
 * @private
 * @function
 */
-export const readYText = decoder => new YText()
+export const readYText = _decoder => new YText()
--- a/src/types/YXmlElement.js
+++ b/src/types/YXmlElement.js
@@ -1,3 +1,4 @@
+import * as object from 'lib0/object'

 import {
  YXmlFragment,
@@ -9,15 +10,21 @@ import {
  typeMapGetAll,
  typeListForEach,
  YXmlElementRefID,
-  YXmlText, ContentType, AbstractType, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Snapshot, Doc, Item // eslint-disable-line
+  YXmlText, ContentType, AbstractType, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Doc, Item // eslint-disable-line
 } from '../internals.js'

+/**
+ * @typedef {Object|number|null|Array<any>|string|Uint8Array|AbstractType<any>} ValueTypes
+ */
+
 /**
 * An YXmlElement imitates the behavior of a
 * {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}.
 *
 * * An YXmlElement has attributes (key value pairs)
 * * An YXmlElement has childElements that must inherit from YXmlElement
+ *
+ * @template {{ [key: string]: ValueTypes }} [KV={ [key: string]: string }]
 */
 export class YXmlElement extends YXmlFragment {
  constructor (nodeName = 'UNDEFINED') {
@@ -73,14 +80,19 @@ export class YXmlElement extends YXmlFragment {
  }

  /**
-   * @return {YXmlElement}
+   * @return {YXmlElement<KV>}
   */
  clone () {
+    /**
+     * @type {YXmlElement<KV>}
+     */
    const el = new YXmlElement(this.nodeName)
    const attrs = this.getAttributes()
-    for (const key in attrs) {
-      el.setAttribute(key, attrs[key])
-    }
+    object.forEach(attrs, (value, key) => {
+      if (typeof value === 'string') {
+        el.setAttribute(key, value)
+      }
+    })
    // @ts-ignore
    el.insert(0, this.toArray().map(item => item instanceof AbstractType ? item.clone() : item))
    return el
@@ -116,7 +128,7 @@ export class YXmlElement extends YXmlFragment {
  /**
   * Removes an attribute from this YXmlElement.
   *
-   * @param {String} attributeName The attribute name that is to be removed.
+   * @param {string} attributeName The attribute name that is to be removed.
   *
   * @public
   */
@@ -133,8 +145,10 @@ export class YXmlElement extends YXmlFragment {
  /**
   * Sets or updates an attribute.
   *
-   * @param {String} attributeName The attribute name that is to be set.
-   * @param {String} attributeValue The attribute value that is to be set.
+   * @template {keyof KV & string} KEY
+   *
+   * @param {KEY} attributeName The attribute name that is to be set.
+   * @param {KV[KEY]} attributeValue The attribute value that is to be set.
   *
   * @public
   */
@@ -151,9 +165,11 @@ export class YXmlElement extends YXmlFragment {
  /**
   * Returns an attribute value that belongs to the attribute name.
   *
-   * @param {String} attributeName The attribute name that identifies the
+   * @template {keyof KV & string} KEY
+   *
+   * @param {KEY} attributeName The attribute name that identifies the
   *                               queried value.
-   * @return {String} The queried attribute value.
+   * @return {KV[KEY]|undefined} The queried attribute value.
   *
   * @public
   */
@@ -164,7 +180,7 @@ export class YXmlElement extends YXmlFragment {
  /**
   * Returns whether an attribute exists
   *
-   * @param {String} attributeName The attribute name to check for existence.
+   * @param {string} attributeName The attribute name to check for existence.
   * @return {boolean} whether the attribute exists.
   *
   * @public
@@ -176,13 +192,12 @@ export class YXmlElement extends YXmlFragment {
  /**
   * Returns all attribute name/value pairs in a JSON Object.
   *
-   * @param {Snapshot} [snapshot]
-   * @return {Object<string, any>} A JSON Object that describes the attributes.
+   * @return {{ [Key in Extract<keyof KV,string>]?: KV[Key]}} A JSON Object that describes the attributes.
   *
   * @public
   */
-  getAttributes (snapshot) {
-    return typeMapGetAll(this)
+  getAttributes () {
+    return /** @type {any} */ (typeMapGetAll(this))
  }

  /**
@@ -204,7 +219,10 @@ export class YXmlElement extends YXmlFragment {
    const dom = _document.createElement(this.nodeName)
    const attrs = this.getAttributes()
    for (const key in attrs) {
-      dom.setAttribute(key, attrs[key])
+      const value = attrs[key]
+      if (typeof value === 'string') {
+        dom.setAttribute(key, value)
+      }
    }
    typeListForEach(this, yxml => {
      dom.appendChild(yxml.toDOM(_document, hooks, binding))
--- a/src/types/YXmlEvent.js
+++ b/src/types/YXmlEvent.js
@@ -5,6 +5,7 @@ import {
 } from '../internals.js'

 /**
+ * @extends YEvent<YXmlElement|YXmlText|YXmlFragment>
 * An Event that describes changes on a YXml Element or Yxml Fragment
 */
 export class YXmlEvent extends YEvent {
--- a/src/types/YXmlFragment.js
+++ b/src/types/YXmlFragment.js
@@ -17,10 +17,11 @@ import {
  transact,
  typeListGet,
  typeListSlice,
-  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Doc, ContentType, Transaction, Item, YXmlText, YXmlHook, Snapshot // eslint-disable-line
+  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Doc, ContentType, Transaction, Item, YXmlText, YXmlHook // eslint-disable-line
 } from '../internals.js'

 import * as error from 'lib0/error'
+import * as array from 'lib0/array'

 /**
 * Define the elements to which a set of CSS queries apply.
@@ -237,7 +238,7 @@ export class YXmlFragment extends AbstractType {
  querySelectorAll (query) {
    query = query.toUpperCase()
    // @ts-ignore
-    return Array.from(new YXmlTreeWalker(this, element => element.nodeName && element.nodeName.toUpperCase() === query))
+    return array.from(new YXmlTreeWalker(this, element => element.nodeName && element.nodeName.toUpperCase() === query))
  }

  /**
@@ -404,6 +405,15 @@ export class YXmlFragment extends AbstractType {
    return typeListSlice(this, start, end)
  }

+  /**
+   * Executes a provided function on once on overy child element.
+   *
+   * @param {function(YXmlElement|YXmlText,number, typeof self):void} f A function to execute on every element of this YArray.
+   */
+  forEach (f) {
+    typeListForEach(this, f)
+  }
+
  /**
   * Transform the properties of this type to binary and write it to an
   * BinaryEncoder.
@@ -418,10 +428,10 @@ export class YXmlFragment extends AbstractType {
 }

 /**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder
 * @return {YXmlFragment}
 *
 * @private
 * @function
 */
-export const readYXmlFragment = decoder => new YXmlFragment()
+export const readYXmlFragment = _decoder => new YXmlFragment()
--- a/src/utils/DeleteSet.js
+++ b/src/utils/DeleteSet.js
@@ -171,7 +171,7 @@ export const mergeDeleteSets = dss => {
 * @function
 */
 export const addToDeleteSet = (ds, client, clock, length) => {
-  map.setIfUndefined(ds.clients, client, () => []).push(new DeleteItem(clock, length))
+  map.setIfUndefined(ds.clients, client, () => /** @type {Array<DeleteItem>} */ ([])).push(new DeleteItem(clock, length))
 }

 export const createDeleteSet = () => new DeleteSet()
@@ -219,17 +219,21 @@ export const createDeleteSetFromStructStore = ss => {
 */
 export const writeDeleteSet = (encoder, ds) => {
  encoding.writeVarUint(encoder.restEncoder, ds.clients.size)
-  ds.clients.forEach((dsitems, client) => {
-    encoder.resetDsCurVal()
-    encoding.writeVarUint(encoder.restEncoder, client)
-    const len = dsitems.length
-    encoding.writeVarUint(encoder.restEncoder, len)
-    for (let i = 0; i < len; i++) {
-      const item = dsitems[i]
-      encoder.writeDsClock(item.clock)
-      encoder.writeDsLen(item.len)
-    }
-  })
+
+  // Ensure that the delete set is written in a deterministic order
+  array.from(ds.clients.entries())
+    .sort((a, b) => b[0] - a[0])
+    .forEach(([client, dsitems]) => {
+      encoder.resetDsCurVal()
+      encoding.writeVarUint(encoder.restEncoder, client)
+      const len = dsitems.length
+      encoding.writeVarUint(encoder.restEncoder, len)
+      for (let i = 0; i < len; i++) {
+        const item = dsitems[i]
+        encoder.writeDsClock(item.clock)
+        encoder.writeDsLen(item.len)
+      }
+    })
 }

 /**
@@ -247,7 +251,7 @@ export const readDeleteSet = decoder => {
    const client = decoding.readVarUint(decoder.restDecoder)
    const numberOfDeletes = decoding.readVarUint(decoder.restDecoder)
    if (numberOfDeletes > 0) {
-      const dsField = map.setIfUndefined(ds.clients, client, () => [])
+      const dsField = map.setIfUndefined(ds.clients, client, () => /** @type {Array<DeleteItem>} */ ([]))
      for (let i = 0; i < numberOfDeletes; i++) {
        dsField.push(new DeleteItem(decoder.readDsClock(), decoder.readDsLen()))
      }
@@ -324,3 +328,23 @@ export const readAndApplyDeleteSet = (decoder, transaction, store) => {
  }
  return null
 }
+
+/**
+ * @param {DeleteSet} ds1
+ * @param {DeleteSet} ds2
+ */
+export const equalDeleteSets = (ds1, ds2) => {
+  if (ds1.clients.size !== ds2.clients.size) return false
+  ds1.clients.forEach((deleteItems1, client) => {
+    const deleteItems2 = /** @type {Array<import('../internals.js').DeleteItem>} */ (ds2.clients.get(client))
+    if (deleteItems2 === undefined || deleteItems1.length !== deleteItems2.length) return false
+    for (let i = 0; i < deleteItems1.length; i++) {
+      const di1 = deleteItems1[i]
+      const di2 = deleteItems2[i]
+      if (di1.clock !== di2.clock || di1.len !== di2.len) {
+        return false
+      }
+    }
+  })
+  return true
+}
--- a/src/utils/Doc.js
+++ b/src/utils/Doc.js
@@ -38,7 +38,7 @@ export const generateNewClientId = random.uint32
 */
 export class Doc extends Observable {
  /**
-   * @param {DocOpts} [opts] configuration
+   * @param {DocOpts} opts configuration
   */
  constructor ({ guid = random.uuidv4(), collectionid = null, gc = true, gcFilter = () => true, meta = null, autoLoad = false, shouldLoad = true } = {}) {
    super()
@@ -48,7 +48,7 @@ export class Doc extends Observable {
    this.guid = guid
    this.collectionid = collectionid
    /**
-     * @type {Map<string, AbstractType<YEvent>>}
+     * @type {Map<string, AbstractType<YEvent<any>>>}
     */
    this.share = new Map()
    this.store = new StructStore()
@@ -72,13 +72,57 @@ export class Doc extends Observable {
    this.shouldLoad = shouldLoad
    this.autoLoad = autoLoad
    this.meta = meta
+    /**
+     * This is set to true when the persistence provider loaded the document from the database or when the `sync` event fires.
+     * Note that not all providers implement this feature. Provider authors are encouraged to fire the `load` event when the doc content is loaded from the database.
+     *
+     * @type {boolean}
+     */
    this.isLoaded = false
+    /**
+     * This is set to true when the connection provider has successfully synced with a backend.
+     * Note that when using peer-to-peer providers this event may not provide very useful.
+     * Also note that not all providers implement this feature. Provider authors are encouraged to fire
+     * the `sync` event when the doc has been synced (with `true` as a parameter) or if connection is
+     * lost (with false as a parameter).
+     */
+    this.isSynced = false
+    /**
+     * Promise that resolves once the document has been loaded from a presistence provider.
+     */
    this.whenLoaded = promise.create(resolve => {
      this.on('load', () => {
        this.isLoaded = true
        resolve(this)
      })
    })
+    const provideSyncedPromise = () => promise.create(resolve => {
+      /**
+       * @param {boolean} isSynced
+       */
+      const eventHandler = (isSynced) => {
+        if (isSynced === undefined || isSynced === true) {
+          this.off('sync', eventHandler)
+          resolve()
+        }
+      }
+      this.on('sync', eventHandler)
+    })
+    this.on('sync', isSynced => {
+      if (isSynced === false && this.isSynced) {
+        this.whenSynced = provideSyncedPromise()
+      }
+      this.isSynced = isSynced === undefined || isSynced === true
+      if (!this.isLoaded) {
+        this.emit('load', [])
+      }
+    })
+    /**
+     * Promise that resolves once the document has been synced with a backend.
+     * This promise is recreated when the connection is lost.
+     * Note the documentation about the `isSynced` property.
+     */
+    this.whenSynced = provideSyncedPromise()
  }

  /**
@@ -103,7 +147,7 @@ export class Doc extends Observable {
  }

  getSubdocGuids () {
-    return new Set(Array.from(this.subdocs).map(doc => doc.guid))
+    return new Set(array.from(this.subdocs).map(doc => doc.guid))
  }

  /**
@@ -112,13 +156,15 @@ export class Doc extends Observable {
   * that happened inside of the transaction are sent as one message to the
   * other peers.
   *
-   * @param {function(Transaction):void} f The function that should be executed as a transaction
+   * @template T
+   * @param {function(Transaction):T} f The function that should be executed as a transaction
   * @param {any} [origin] Origin of who started the transaction. Will be stored on transaction.origin
+   * @return T
   *
   * @public
   */
  transact (f, origin = null) {
-    transact(this, f, origin)
+    return transact(this, f, origin)
  }

  /**
--- a/src/utils/PermanentUserData.js
+++ b/src/utils/PermanentUserData.js
@@ -71,7 +71,7 @@ export class PermanentUserData {
   * @param {Doc} doc
   * @param {number} clientid
   * @param {string} userDescription
-   * @param {Object} [conf]
+   * @param {Object} conf
   * @param {function(Transaction, DeleteSet):boolean} [conf.filter]
   */
  setUserMapping (doc, clientid, userDescription, { filter = () => true } = {}) {
@@ -84,7 +84,7 @@ export class PermanentUserData {
      users.set(userDescription, user)
    }
    user.get('ids').push([clientid])
-    users.observe(event => {
+    users.observe(_event => {
      setTimeout(() => {
        const userOverwrite = users.get(userDescription)
        if (userOverwrite !== user) {
--- a/src/utils/Snapshot.js
+++ b/src/utils/Snapshot.js
@@ -15,7 +15,10 @@ import {
  findIndexSS,
  UpdateEncoderV2,
  applyUpdateV2,
-  DSEncoderV1, DSEncoderV2, DSDecoderV1, DSDecoderV2, Transaction, Doc, DeleteSet, Item // eslint-disable-line
+  LazyStructReader,
+  equalDeleteSets,
+  UpdateDecoderV1, UpdateDecoderV2, DSEncoderV1, DSEncoderV2, DSDecoderV1, DSDecoderV2, Transaction, Doc, DeleteSet, Item, // eslint-disable-line
+  mergeDeleteSets
 } from '../internals.js'

 import * as map from 'lib0/map'
@@ -147,12 +150,20 @@ export const splitSnapshotAffectedStructs = (transaction, snapshot) => {
        getItemCleanStart(transaction, createID(client, clock))
      }
    })
-    iterateDeletedStructs(transaction, snapshot.ds, item => {})
+    iterateDeletedStructs(transaction, snapshot.ds, _item => {})
    meta.add(snapshot)
  }
 }

 /**
+ * @example
+ *  const ydoc = new Y.Doc({ gc: false })
+ *  ydoc.getText().insert(0, 'world!')
+ *  const snapshot = Y.snapshot(ydoc)
+ *  ydoc.getText().insert(0, 'hello ')
+ *  const restored = Y.createDocFromSnapshot(ydoc, snapshot)
+ *  assert(restored.getText().toString() === 'world!')
+ *
 * @param {Doc} originDoc
 * @param {Snapshot} snapshot
 * @param {Doc} [newDoc] Optionally, you may define the Yjs document that receives the data from originDoc
@@ -161,7 +172,7 @@ export const splitSnapshotAffectedStructs = (transaction, snapshot) => {
 export const createDocFromSnapshot = (originDoc, snapshot, newDoc = new Doc()) => {
  if (originDoc.gc) {
    // we should not try to restore a GC-ed document, because some of the restored items might have their content deleted
-    throw new Error('originDoc must not be garbage collected')
+    throw new Error('Garbage-collection must be disabled in `originDoc`!')
  }
  const { sv, ds } = snapshot

@@ -199,3 +210,28 @@ export const createDocFromSnapshot = (originDoc, snapshot, newDoc = new Doc()) =
  applyUpdateV2(newDoc, encoder.toUint8Array(), 'snapshot')
  return newDoc
 }
+
+/**
+ * @param {Snapshot} snapshot
+ * @param {Uint8Array} update
+ * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]
+ */
+export const snapshotContainsUpdateV2 = (snapshot, update, YDecoder = UpdateDecoderV2) => {
+  const structs = []
+  const updateDecoder = new YDecoder(decoding.createDecoder(update))
+  const lazyDecoder = new LazyStructReader(updateDecoder, false)
+  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
+    structs.push(curr)
+    if ((snapshot.sv.get(curr.id.client) || 0) < curr.id.clock + curr.length) {
+      return false
+    }
+  }
+  const mergedDS = mergeDeleteSets([snapshot.ds, readDeleteSet(updateDecoder)])
+  return equalDeleteSets(snapshot.ds, mergedDS)
+}
+
+/**
+ * @param {Snapshot} snapshot
+ * @param {Uint8Array} update
+ */
+export const snapshotContainsUpdate = (snapshot, update) => snapshotContainsUpdateV2(snapshot, update, UpdateDecoderV1)
--- a/src/utils/Transaction.js
+++ b/src/utils/Transaction.js
@@ -75,13 +75,13 @@ 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)
-     * @type {Map<AbstractType<YEvent>,Set<String|null>>}
+     * @type {Map<AbstractType<YEvent<any>>,Set<String|null>>}
     */
    this.changed = new Map()
    /**
     * Stores the events for the types that observe also child elements.
     * It is mainly used by `observeDeep`.
-     * @type {Map<AbstractType<YEvent>,Array<YEvent>>}
+     * @type {Map<AbstractType<YEvent<any>>,Array<YEvent<any>>>}
     */
    this.changedParentTypes = new Map()
    /**
@@ -148,7 +148,7 @@ export const nextID = transaction => {
 * did not change, it was just added and we should not fire events for `type`.
 *
 * @param {Transaction} transaction
- * @param {AbstractType<YEvent>} type
+ * @param {AbstractType<YEvent<any>>} type
 * @param {string|null} parentSub
 */
 export const addChangedTypeToTransaction = (transaction, type, parentSub) => {
@@ -251,7 +251,6 @@ const cleanupTransactions = (transactionCleanups, i) => {
    try {
      sortAndMergeDeleteSet(ds)
      transaction.afterState = getStateVector(transaction.doc.store)
-      doc._transaction = null
      doc.emit('beforeObserverCalls', [transaction, doc])
      /**
       * An array of event callbacks.
@@ -377,15 +376,21 @@ const cleanupTransactions = (transactionCleanups, i) => {
 /**
 * Implements the functionality of `y.transact(()=>{..})`
 *
+ * @template T
 * @param {Doc} doc
- * @param {function(Transaction):void} f
+ * @param {function(Transaction):T} f
 * @param {any} [origin=true]
+ * @return {T}
 *
 * @function
 */
 export const transact = (doc, f, origin = null, local = true) => {
  const transactionCleanups = doc._transactionCleanups
  let initialCall = false
+  /**
+   * @type {any}
+   */
+  let result = null
  if (doc._transaction === null) {
    initialCall = true
    doc._transaction = new Transaction(doc, origin, local)
@@ -396,18 +401,23 @@ export const transact = (doc, f, origin = null, local = true) => {
    doc.emit('beforeTransaction', [doc._transaction, doc])
  }
  try {
-    f(doc._transaction)
+    result = f(doc._transaction)
  } finally {
-    if (initialCall && transactionCleanups[0] === doc._transaction) {
-      // The first transaction ended, now process observer calls.
-      // Observer call may create new transactions for which we need to call the observers and do cleanup.
-      // We don't want to nest these calls, so we execute these calls one after
-      // another.
-      // Also we need to ensure that all cleanups are called, even if the
-      // observes throw errors.
-      // This file is full of hacky try {} finally {} blocks to ensure that an
-      // event can throw errors and also that the cleanup is called.
-      cleanupTransactions(transactionCleanups, 0)
+    if (initialCall) {
+      const finishCleanup = doc._transaction === transactionCleanups[0]
+      doc._transaction = null
+      if (finishCleanup) {
+        // The first transaction ended, now process observer calls.
+        // Observer call may create new transactions for which we need to call the observers and do cleanup.
+        // We don't want to nest these calls, so we execute these calls one after
+        // another.
+        // Also we need to ensure that all cleanups are called, even if the
+        // observes throw errors.
+        // This file is full of hacky try {} finally {} blocks to ensure that an
+        // event can throw errors and also that the cleanup is called.
+        cleanupTransactions(transactionCleanups, 0)
+      }
    }
  }
+  return result
 }
--- a/src/utils/UndoManager.js
+++ b/src/utils/UndoManager.js
@@ -10,13 +10,14 @@ import {
  getItemCleanStart,
  isDeleted,
  addToDeleteSet,
-  Transaction, Doc, Item, GC, DeleteSet, AbstractType, YEvent // eslint-disable-line
+  Transaction, Doc, Item, GC, DeleteSet, AbstractType // eslint-disable-line
 } from '../internals.js'

 import * as time from 'lib0/time'
+import * as array from 'lib0/array'
 import { Observable } from 'lib0/observable'

-class StackItem {
+export class StackItem {
  /**
   * @param {DeleteSet} deletions
   * @param {DeleteSet} insertions
@@ -30,6 +31,18 @@ class StackItem {
    this.meta = new Map()
  }
 }
+/**
+ * @param {Transaction} tr
+ * @param {UndoManager} um
+ * @param {StackItem} stackItem
+ */
+const clearUndoManagerStackItem = (tr, um, stackItem) => {
+  iterateDeletedStructs(tr, stackItem.deletions, item => {
+    if (item instanceof Item && um.scope.some(type => isParentOf(type, item))) {
+      keepItem(item, false)
+    }
+  })
+}

 /**
 * @param {UndoManager} undoManager
@@ -88,7 +101,7 @@ const popStackItem = (undoManager, stack, eventType) => {
        }
      })
      itemsToRedo.forEach(struct => {
-        performedChange = redoItem(transaction, struct, itemsToRedo, itemsToDelete) !== null || performedChange
+        performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.insertions, undoManager.ignoreRemoteMapChanges, undoManager) !== null || performedChange
      })
      // We want to delete in reverse order so that children are deleted before
      // parents, so we have more information available when items are filtered.
@@ -119,11 +132,14 @@ const popStackItem = (undoManager, stack, eventType) => {
 /**
 * @typedef {Object} UndoManagerOptions
 * @property {number} [UndoManagerOptions.captureTimeout=500]
+ * @property {function(Transaction):boolean} [UndoManagerOptions.captureTransaction] Do not capture changes of a Transaction if result false.
 * @property {function(Item):boolean} [UndoManagerOptions.deleteFilter=()=>true] Sometimes
- * it is necessary to filter whan an Undo/Redo operation can delete. If this
+ * it is necessary to filter what 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])]
+ * @property {boolean} [ignoreRemoteMapChanges] Experimental. By default, the UndoManager will never overwrite remote changes. Enable this property to enable overwriting remote changes on key-value changes (Y.Map, properties on Y.Xml, etc..).
+ * @property {Doc} [doc] The document that this UndoManager operates on. Only needed if typeScope is empty.
 */

 /**
@@ -133,19 +149,31 @@ const popStackItem = (undoManager, stack, eventType) => {
 * 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'>}
+ * @extends {Observable<'stack-item-added'|'stack-item-popped'|'stack-cleared'|'stack-item-updated'>}
 */
 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 = 500, deleteFilter = () => true, trackedOrigins = new Set([null]) } = {}) {
+  constructor (typeScope, {
+    captureTimeout = 500,
+    captureTransaction = _tr => true,
+    deleteFilter = () => true,
+    trackedOrigins = new Set([null]),
+    ignoreRemoteMapChanges = false,
+    doc = /** @type {Doc} */ (array.isArray(typeScope) ? typeScope[0].doc : typeScope.doc)
+  } = {}) {
    super()
-    this.scope = typeScope instanceof Array ? typeScope : [typeScope]
+    /**
+     * @type {Array<AbstractType<any>>}
+     */
+    this.scope = []
+    this.addToScope(typeScope)
    this.deleteFilter = deleteFilter
    trackedOrigins.add(this)
    this.trackedOrigins = trackedOrigins
+    this.captureTransaction = captureTransaction
    /**
     * @type {Array<StackItem>}
     */
@@ -161,11 +189,20 @@ export class UndoManager extends Observable {
     */
    this.undoing = false
    this.redoing = false
-    this.doc = /** @type {Doc} */ (this.scope[0].doc)
+    this.doc = doc
    this.lastChange = 0
-    this.doc.on('afterTransaction', /** @param {Transaction} transaction */ transaction => {
+    this.ignoreRemoteMapChanges = ignoreRemoteMapChanges
+    this.captureTimeout = captureTimeout
+    /**
+     * @param {Transaction} transaction
+     */
+    this.afterTransactionHandler = 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)))) {
+      if (
+        !this.captureTransaction(transaction) ||
+        !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
@@ -175,7 +212,7 @@ export class UndoManager extends Observable {
        this.stopCapturing() // next undo should not be appended to last stack item
      } else if (!redoing) {
        // neither undoing nor redoing: delete redoStack
-        this.redoStack = []
+        this.clear(false, true)
      }
      const insertions = new DeleteSet()
      transaction.afterState.forEach((endClock, client) => {
@@ -186,7 +223,8 @@ export class UndoManager extends Observable {
        }
      })
      const now = time.getUnixTime()
-      if (now - this.lastChange < captureTimeout && stack.length > 0 && !undoing && !redoing) {
+      let didAdd = false
+      if (this.lastChange > 0 && now - this.lastChange < this.captureTimeout && stack.length > 0 && !undoing && !redoing) {
        // append change to last stack op
        const lastOp = stack[stack.length - 1]
        lastOp.deletions = mergeDeleteSets([lastOp.deletions, transaction.deleteSet])
@@ -194,6 +232,7 @@ export class UndoManager extends Observable {
      } else {
        // create a new stack op
        stack.push(new StackItem(transaction.deleteSet, insertions))
+        didAdd = true
      }
      if (!undoing && !redoing) {
        this.lastChange = now
@@ -204,27 +243,59 @@ export class UndoManager extends Observable {
          keepItem(item, true)
        }
      })
-      this.emit('stack-item-added', [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? 'redo' : 'undo', changedParentTypes: transaction.changedParentTypes }, this])
+      const changeEvent = [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? 'redo' : 'undo', changedParentTypes: transaction.changedParentTypes }, this]
+      if (didAdd) {
+        this.emit('stack-item-added', changeEvent)
+      } else {
+        this.emit('stack-item-updated', changeEvent)
+      }
+    }
+    this.doc.on('afterTransaction', this.afterTransactionHandler)
+    this.doc.on('destroy', () => {
+      this.destroy()
    })
  }

-  clear () {
-    this.doc.transact(transaction => {
-      /**
-       * @param {StackItem} stackItem
-       */
-      const clearItem = stackItem => {
-        iterateDeletedStructs(transaction, stackItem.deletions, item => {
-          if (item instanceof Item && this.scope.some(type => isParentOf(type, item))) {
-            keepItem(item, false)
-          }
-        })
+  /**
+   * @param {Array<AbstractType<any>> | AbstractType<any>} ytypes
+   */
+  addToScope (ytypes) {
+    ytypes = array.isArray(ytypes) ? ytypes : [ytypes]
+    ytypes.forEach(ytype => {
+      if (this.scope.every(yt => yt !== ytype)) {
+        this.scope.push(ytype)
      }
-      this.undoStack.forEach(clearItem)
-      this.redoStack.forEach(clearItem)
    })
-    this.undoStack = []
-    this.redoStack = []
+  }
+
+  /**
+   * @param {any} origin
+   */
+  addTrackedOrigin (origin) {
+    this.trackedOrigins.add(origin)
+  }
+
+  /**
+   * @param {any} origin
+   */
+  removeTrackedOrigin (origin) {
+    this.trackedOrigins.delete(origin)
+  }
+
+  clear (clearUndoStack = true, clearRedoStack = true) {
+    if ((clearUndoStack && this.canUndo()) || (clearRedoStack && this.canRedo())) {
+      this.doc.transact(tr => {
+        if (clearUndoStack) {
+          this.undoStack.forEach(item => clearUndoManagerStackItem(tr, this, item))
+          this.undoStack = []
+        }
+        if (clearRedoStack) {
+          this.redoStack.forEach(item => clearUndoManagerStackItem(tr, this, item))
+          this.redoStack = []
+        }
+        this.emit('stack-cleared', [{ undoStackCleared: clearUndoStack, redoStackCleared: clearRedoStack }])
+      })
+    }
  }

  /**
@@ -282,4 +353,28 @@ export class UndoManager extends Observable {
    }
    return res
  }
+
+  /**
+   * Are undo steps available?
+   *
+   * @return {boolean} `true` if undo is possible
+   */
+  canUndo () {
+    return this.undoStack.length > 0
+  }
+
+  /**
+   * Are redo steps available?
+   *
+   * @return {boolean} `true` if redo is possible
+   */
+  canRedo () {
+    return this.redoStack.length > 0
+  }
+
+  destroy () {
+    this.trackedOrigins.delete(this)
+    this.doc.off('afterTransaction', this.afterTransactionHandler)
+    super.destroy()
+  }
 }
--- a/src/utils/UpdateEncoder.js
+++ b/src/utils/UpdateEncoder.js
@@ -298,10 +298,24 @@ export class UpdateEncoderV2 extends DSEncoderV2 {
  writeKey (key) {
    const clock = this.keyMap.get(key)
    if (clock === undefined) {
+      /**
+       * @todo uncomment to introduce this feature finally
+       *
+       * Background. The ContentFormat object was always encoded using writeKey, but the decoder used to use readString.
+       * Furthermore, I forgot to set the keyclock. So everything was working fine.
+       *
+       * However, this feature here is basically useless as it is not being used (it actually only consumes extra memory).
+       *
+       * I don't know yet how to reintroduce this feature..
+       *
+       * Older clients won't be able to read updates when we reintroduce this feature. So this should probably be done using a flag.
+       *
+       */
+      // this.keyMap.set(key, this.keyClock)
      this.keyClockEncoder.write(this.keyClock++)
      this.stringEncoder.write(key)
    } else {
-      this.keyClockEncoder.write(this.keyClock++)
+      this.keyClockEncoder.write(clock)
    }
  }
 }
--- a/src/utils/YEvent.js
+++ b/src/utils/YEvent.js
@@ -8,17 +8,18 @@ import * as set from 'lib0/set'
 import * as array from 'lib0/array'

 /**
+ * @template {AbstractType<any>} T
 * YEvent describes the changes on a YType.
 */
 export class YEvent {
  /**
-   * @param {AbstractType<any>} target The changed type.
+   * @param {T} target The changed type.
   * @param {Transaction} transaction
   */
  constructor (target, transaction) {
    /**
     * The type on which this event was created on.
-     * @type {AbstractType<any>}
+     * @type {T}
     */
    this.target = target
    /**
@@ -129,6 +130,11 @@ export class YEvent {
  }

  /**
+   * This is a computed property. Note that this can only be safely computed during the
+   * event call. Computing this property after other changes happened might result in
+   * unexpected behavior (incorrect computation of deltas). A safe way to collect changes
+   * is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.
+   *
   * @type {Array<{insert?: string | Array<any> | object | AbstractType<any>, retain?: number, delete?: number, attributes?: Object<string, any>}>}
   */
  get delta () {
@@ -148,6 +154,11 @@ export class YEvent {
  }

  /**
+   * This is a computed property. Note that this can only be safely computed during the
+   * event call. Computing this property after other changes happened might result in
+   * unexpected behavior (incorrect computation of deltas). A safe way to collect changes
+   * is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.
+   *
   * @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'|'update'|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>|string, delete?:number, retain?:number}>}}
   */
  get changes () {
--- a/src/utils/encoding.js
+++ b/src/utils/encoding.js
@@ -45,6 +45,7 @@ import * as decoding from 'lib0/decoding'
 import * as binary from 'lib0/binary'
 import * as map from 'lib0/map'
 import * as math from 'lib0/math'
+import * as array from 'lib0/array'

 /**
 * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
@@ -87,7 +88,7 @@ export const writeClientsStructs = (encoder, store, _sm) => {
      sm.set(client, clock)
    }
  })
-  getStateVector(store).forEach((clock, client) => {
+  getStateVector(store).forEach((_clock, client) => {
    if (!_sm.has(client)) {
      sm.set(client, 0)
    }
@@ -96,9 +97,8 @@ export const writeClientsStructs = (encoder, store, _sm) => {
  encoding.writeVarUint(encoder.restEncoder, sm.size)
  // Write items with higher client ids first
  // This heavily improves the conflict algorithm.
-  Array.from(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
-    // @ts-ignore
-    writeStructs(encoder, store.clients.get(client), client, clock)
+  array.from(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
+    writeStructs(encoder, /** @type {Array<GC|Item>} */ (store.clients.get(client)), client, clock)
  })
 }

@@ -231,7 +231,7 @@ const integrateStructs = (transaction, store, clientsStructRefs) => {
   */
  const stack = []
  // sort them so that we take the higher id first, in case of conflicts the lower id will probably not conflict with the id from the higher user.
-  let clientsStructRefsIds = Array.from(clientsStructRefs.keys()).sort((a, b) => a - b)
+  let clientsStructRefsIds = array.from(clientsStructRefs.keys()).sort((a, b) => a - b)
  if (clientsStructRefsIds.length === 0) {
    return null
  }
@@ -601,7 +601,7 @@ export const decodeStateVector = decodedState => readStateVector(new DSDecoderV1
 */
 export const writeStateVector = (encoder, sv) => {
  encoding.writeVarUint(encoder.restEncoder, sv.size)
-  Array.from(sv.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
+  array.from(sv.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
    encoding.writeVarUint(encoder.restEncoder, client) // @todo use a special client decoder that is based on mapping
    encoding.writeVarUint(encoder.restEncoder, clock)
  })
--- a/src/utils/updates.js
+++ b/src/utils/updates.js
@@ -2,19 +2,40 @@
 import * as binary from 'lib0/binary'
 import * as decoding from 'lib0/decoding'
 import * as encoding from 'lib0/encoding'
+import * as error from 'lib0/error'
+import * as f from 'lib0/function'
 import * as logging from 'lib0/logging'
+import * as map from 'lib0/map'
 import * as math from 'lib0/math'
+import * as string from 'lib0/string'
+
 import {
+  ContentAny,
+  ContentBinary,
+  ContentDeleted,
+  ContentDoc,
+  ContentEmbed,
+  ContentFormat,
+  ContentJSON,
+  ContentString,
+  ContentType,
  createID,
-  readItemContent,
-  readDeleteSet,
-  writeDeleteSet,
-  Skip,
-  mergeDeleteSets,
+  decodeStateVector,
  DSEncoderV1,
  DSEncoderV2,
-  decodeStateVector,
-  Item, GC, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2 // eslint-disable-line
+  GC,
+  Item,
+  mergeDeleteSets,
+  readDeleteSet,
+  readItemContent,
+  Skip,
+  UpdateDecoderV1,
+  UpdateDecoderV2,
+  UpdateEncoderV1,
+  UpdateEncoderV2,
+  writeDeleteSet,
+  YXmlElement,
+  YXmlHook
 } from '../internals.js'

 /**
@@ -112,6 +133,30 @@ export const logUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
  logging.print('DeleteSet: ', ds)
 }

+/**
+ * @param {Uint8Array} update
+ *
+ */
+export const decodeUpdate = (update) => decodeUpdateV2(update, UpdateDecoderV1)
+
+/**
+ * @param {Uint8Array} update
+ * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]
+ *
+ */
+export const decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
+  const structs = []
+  const updateDecoder = new YDecoder(decoding.createDecoder(update))
+  const lazyDecoder = new LazyStructReader(updateDecoder, false)
+  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
+    structs.push(curr)
+  }
+  return {
+    structs,
+    ds: readDeleteSet(updateDecoder)
+  }
+}
+
 export class LazyStructWriter {
  /**
   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
@@ -528,17 +573,17 @@ const finishLazyStructWriting = (lazyWriter) => {

 /**
 * @param {Uint8Array} update
+ * @param {function(Item|GC|Skip):Item|GC|Skip} blockTransformer
 * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} YDecoder
 * @param {typeof UpdateEncoderV2 | typeof UpdateEncoderV1 } YEncoder
 */
-export const convertUpdateFormat = (update, YDecoder, YEncoder) => {
+export const convertUpdateFormat = (update, blockTransformer, YDecoder, YEncoder) => {
  const updateDecoder = new YDecoder(decoding.createDecoder(update))
  const lazyDecoder = new LazyStructReader(updateDecoder, false)
  const updateEncoder = new YEncoder()
  const lazyWriter = new LazyStructWriter(updateEncoder)
-
  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
-    writeStructToLazyStructWriter(lazyWriter, curr, 0)
+    writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0)
  }
  finishLazyStructWriting(lazyWriter)
  const ds = readDeleteSet(updateDecoder)
@@ -547,11 +592,132 @@ export const convertUpdateFormat = (update, YDecoder, YEncoder) => {
 }

 /**
- * @param {Uint8Array} update
+ * @typedef {Object} ObfuscatorOptions
+ * @property {boolean} [ObfuscatorOptions.formatting=true]
+ * @property {boolean} [ObfuscatorOptions.subdocs=true]
+ * @property {boolean} [ObfuscatorOptions.yxml=true] Whether to obfuscate nodeName / hookName
 */
-export const convertUpdateFormatV1ToV2 = update => convertUpdateFormat(update, UpdateDecoderV1, UpdateEncoderV2)
+
+/**
+ * @param {ObfuscatorOptions} obfuscator
+ */
+const createObfuscator = ({ formatting = true, subdocs = true, yxml = true } = {}) => {
+  let i = 0
+  const mapKeyCache = map.create()
+  const nodeNameCache = map.create()
+  const formattingKeyCache = map.create()
+  const formattingValueCache = map.create()
+  formattingValueCache.set(null, null) // end of a formatting range should always be the end of a formatting range
+  /**
+   * @param {Item|GC|Skip} block
+   * @return {Item|GC|Skip}
+   */
+  return block => {
+    switch (block.constructor) {
+      case GC:
+      case Skip:
+        return block
+      case Item: {
+        const item = /** @type {Item} */ (block)
+        const content = item.content
+        switch (content.constructor) {
+          case ContentDeleted:
+            break
+          case ContentType: {
+            if (yxml) {
+              const type = /** @type {ContentType} */ (content).type
+              if (type instanceof YXmlElement) {
+                type.nodeName = map.setIfUndefined(nodeNameCache, type.nodeName, () => 'node-' + i)
+              }
+              if (type instanceof YXmlHook) {
+                type.hookName = map.setIfUndefined(nodeNameCache, type.hookName, () => 'hook-' + i)
+              }
+            }
+            break
+          }
+          case ContentAny: {
+            const c = /** @type {ContentAny} */ (content)
+            c.arr = c.arr.map(() => i)
+            break
+          }
+          case ContentBinary: {
+            const c = /** @type {ContentBinary} */ (content)
+            c.content = new Uint8Array([i])
+            break
+          }
+          case ContentDoc: {
+            const c = /** @type {ContentDoc} */ (content)
+            if (subdocs) {
+              c.opts = {}
+              c.doc.guid = i + ''
+            }
+            break
+          }
+          case ContentEmbed: {
+            const c = /** @type {ContentEmbed} */ (content)
+            c.embed = {}
+            break
+          }
+          case ContentFormat: {
+            const c = /** @type {ContentFormat} */ (content)
+            if (formatting) {
+              c.key = map.setIfUndefined(formattingKeyCache, c.key, () => i + '')
+              c.value = map.setIfUndefined(formattingValueCache, c.value, () => ({ i }))
+            }
+            break
+          }
+          case ContentJSON: {
+            const c = /** @type {ContentJSON} */ (content)
+            c.arr = c.arr.map(() => i)
+            break
+          }
+          case ContentString: {
+            const c = /** @type {ContentString} */ (content)
+            c.str = string.repeat((i % 10) + '', c.str.length)
+            break
+          }
+          default:
+            // unknown content type
+            error.unexpectedCase()
+        }
+        if (item.parentSub) {
+          item.parentSub = map.setIfUndefined(mapKeyCache, item.parentSub, () => i + '')
+        }
+        i++
+        return block
+      }
+      default:
+        // unknown block-type
+        error.unexpectedCase()
+    }
+  }
+}
+
+/**
+ * This function obfuscates the content of a Yjs update. This is useful to share
+ * buggy Yjs documents while significantly limiting the possibility that a
+ * developer can on the user. Note that it might still be possible to deduce
+ * some information by analyzing the "structure" of the document or by analyzing
+ * the typing behavior using the CRDT-related metadata that is still kept fully
+ * intact.
+ *
+ * @param {Uint8Array} update
+ * @param {ObfuscatorOptions} [opts]
+ */
+export const obfuscateUpdate = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV1, UpdateEncoderV1)
+
+/**
+ * @param {Uint8Array} update
+ * @param {ObfuscatorOptions} [opts]
+ */
+export const obfuscateUpdateV2 = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV2, UpdateEncoderV2)

 /**
 * @param {Uint8Array} update
 */
-export const convertUpdateFormatV2ToV1 = update => convertUpdateFormat(update, UpdateDecoderV2, UpdateEncoderV1)
+export const convertUpdateFormatV1ToV2 = update => convertUpdateFormat(update, f.id, UpdateDecoderV1, UpdateEncoderV2)
+
+/**
+ * @param {Uint8Array} update
+ */
+export const convertUpdateFormatV2ToV1 = update => convertUpdateFormat(update, f.id, UpdateDecoderV2, UpdateEncoderV1)
--- a/tests/doc.tests.js
+++ b/tests/doc.tests.js
@@ -2,12 +2,55 @@
 import * as Y from '../src/index.js'
 import * as t from 'lib0/testing'

+/**
+ * @param {t.TestCase} _tc
+ */
+export const testAfterTransactionRecursion = _tc => {
+  const ydoc = new Y.Doc()
+  const yxml = ydoc.getXmlFragment('')
+  ydoc.on('afterTransaction', tr => {
+    if (tr.origin === 'test') {
+      yxml.toJSON()
+    }
+  })
+  ydoc.transact(_tr => {
+    for (let i = 0; i < 15000; i++) {
+      yxml.push([new Y.XmlText('a')])
+    }
+  }, 'test')
+}
+
+/**
+ * @param {t.TestCase} _tc
+ */
+export const testOriginInTransaction = _tc => {
+  const doc = new Y.Doc()
+  const ytext = doc.getText()
+  /**
+   * @type {Array<string>}
+   */
+  const origins = []
+  doc.on('afterTransaction', (tr) => {
+    origins.push(tr.origin)
+    if (origins.length <= 1) {
+      ytext.toDelta(Y.snapshot(doc)) // adding a snapshot forces toDelta to create a cleanup transaction
+      doc.transact(() => {
+        ytext.insert(0, 'a')
+      }, 'nested')
+    }
+  })
+  doc.transact(() => {
+    ytext.insert(0, '0')
+  }, 'first')
+  t.compareArrays(origins, ['first', 'cleanup', 'nested'])
+}
+
 /**
 * Client id should be changed when an instance receives updates from another client using the same client id.
 *
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testClientIdDuplicateChange = tc => {
+export const testClientIdDuplicateChange = _tc => {
  const doc1 = new Y.Doc()
  doc1.clientID = 0
  const doc2 = new Y.Doc()
@@ -19,9 +62,9 @@ export const testClientIdDuplicateChange = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testGetTypeEmptyId = tc => {
+export const testGetTypeEmptyId = _tc => {
  const doc1 = new Y.Doc()
  doc1.getText('').insert(0, 'h')
  doc1.getText().insert(1, 'i')
@@ -32,9 +75,9 @@ export const testGetTypeEmptyId = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testToJSON = tc => {
+export const testToJSON = _tc => {
  const doc = new Y.Doc()
  t.compare(doc.toJSON(), {}, 'doc.toJSON yields empty object')

@@ -59,9 +102,9 @@ export const testToJSON = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testSubdoc = tc => {
+export const testSubdoc = _tc => {
  const doc = new Y.Doc()
  doc.load() // doesn't do anything
  {
@@ -126,9 +169,9 @@ export const testSubdoc = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testSubdocLoadEdgeCases = tc => {
+export const testSubdocLoadEdgeCases = _tc => {
  const ydoc = new Y.Doc()
  const yarray = ydoc.getArray()
  const subdoc1 = new Y.Doc()
@@ -173,9 +216,9 @@ export const testSubdocLoadEdgeCases = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testSubdocLoadEdgeCasesAutoload = tc => {
+export const testSubdocLoadEdgeCasesAutoload = _tc => {
  const ydoc = new Y.Doc()
  const yarray = ydoc.getArray()
  const subdoc1 = new Y.Doc({ autoLoad: true })
@@ -215,9 +258,9 @@ export const testSubdocLoadEdgeCasesAutoload = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testSubdocsUndo = tc => {
+export const testSubdocsUndo = _tc => {
  const ydoc = new Y.Doc()
  const elems = ydoc.getXmlFragment()
  const undoManager = new Y.UndoManager(elems)
@@ -230,9 +273,9 @@ export const testSubdocsUndo = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testLoadDocs = async tc => {
+export const testLoadDocsEvent = async _tc => {
  const ydoc = new Y.Doc()
  t.assert(ydoc.isLoaded === false)
  let loadedEvent = false
@@ -244,3 +287,44 @@ export const testLoadDocs = async tc => {
  t.assert(loadedEvent)
  t.assert(ydoc.isLoaded)
 }
+
+/**
+ * @param {t.TestCase} _tc
+ */
+export const testSyncDocsEvent = async _tc => {
+  const ydoc = new Y.Doc()
+  t.assert(ydoc.isLoaded === false)
+  t.assert(ydoc.isSynced === false)
+  let loadedEvent = false
+  ydoc.once('load', () => {
+    loadedEvent = true
+  })
+  let syncedEvent = false
+  ydoc.once('sync', /** @param {any} isSynced */ (isSynced) => {
+    syncedEvent = true
+    t.assert(isSynced)
+  })
+  ydoc.emit('sync', [true, ydoc])
+  await ydoc.whenLoaded
+  const oldWhenSynced = ydoc.whenSynced
+  await ydoc.whenSynced
+  t.assert(loadedEvent)
+  t.assert(syncedEvent)
+  t.assert(ydoc.isLoaded)
+  t.assert(ydoc.isSynced)
+  let loadedEvent2 = false
+  ydoc.on('load', () => {
+    loadedEvent2 = true
+  })
+  let syncedEvent2 = false
+  ydoc.on('sync', (isSynced) => {
+    syncedEvent2 = true
+    t.assert(isSynced === false)
+  })
+  ydoc.emit('sync', [false, ydoc])
+  t.assert(!loadedEvent2)
+  t.assert(syncedEvent2)
+  t.assert(ydoc.isLoaded)
+  t.assert(!ydoc.isSynced)
+  t.assert(ydoc.whenSynced !== oldWhenSynced)
+}
--- a/tests/encoding.tests.js
+++ b/tests/encoding.tests.js
@@ -72,9 +72,9 @@ export const testPermanentUserData = async tc => {
 export const testDiffStateVectorOfUpdateIsEmpty = tc => {
  const ydoc = new Y.Doc()
  /**
-   * @type {null | Uint8Array}
+   * @type {any}
   */
-  let sv = /* any */ (null)
+  let sv = null
  ydoc.getText().insert(0, 'a')
  ydoc.on('update', update => {
    sv = Y.encodeStateVectorFromUpdate(update)
--- a/tests/index.js
+++ b/tests/index.js
@@ -1,3 +1,4 @@
+/* eslint-env node */

 import * as map from './y-map.tests.js'
 import * as array from './y-array.tests.js'
--- a/tests/snapshot.tests.js
+++ b/tests/snapshot.tests.js
@@ -3,9 +3,21 @@ import * as t from 'lib0/testing'
 import { init } from './testHelper.js'

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testBasicRestoreSnapshot = tc => {
+export const testBasic = _tc => {
+  const ydoc = new Y.Doc({ gc: false })
+  ydoc.getText().insert(0, 'world!')
+  const snapshot = Y.snapshot(ydoc)
+  ydoc.getText().insert(0, 'hello ')
+  const restored = Y.createDocFromSnapshot(ydoc, snapshot)
+  t.assert(restored.getText().toString() === 'world!')
+}
+
+/**
+ * @param {t.TestCase} _tc
+ */
+export const testBasicRestoreSnapshot = _tc => {
  const doc = new Y.Doc({ gc: false })
  doc.getArray('array').insert(0, ['hello'])
  const snap = Y.snapshot(doc)
@@ -18,9 +30,9 @@ export const testBasicRestoreSnapshot = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testEmptyRestoreSnapshot = tc => {
+export const testEmptyRestoreSnapshot = _tc => {
  const doc = new Y.Doc({ gc: false })
  const snap = Y.snapshot(doc)
  snap.sv.set(9999, 0)
@@ -38,9 +50,9 @@ export const testEmptyRestoreSnapshot = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testRestoreSnapshotWithSubType = tc => {
+export const testRestoreSnapshotWithSubType = _tc => {
  const doc = new Y.Doc({ gc: false })
  doc.getArray('array').insert(0, [new Y.Map()])
  const subMap = doc.getArray('array').get(0)
@@ -61,9 +73,9 @@ export const testRestoreSnapshotWithSubType = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testRestoreDeletedItem1 = tc => {
+export const testRestoreDeletedItem1 = _tc => {
  const doc = new Y.Doc({ gc: false })
  doc.getArray('array').insert(0, ['item1', 'item2'])

@@ -77,9 +89,9 @@ export const testRestoreDeletedItem1 = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testRestoreLeftItem = tc => {
+export const testRestoreLeftItem = _tc => {
  const doc = new Y.Doc({ gc: false })
  doc.getArray('array').insert(0, ['item1'])
  doc.getMap('map').set('test', 1)
@@ -95,9 +107,9 @@ export const testRestoreLeftItem = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testDeletedItemsBase = tc => {
+export const testDeletedItemsBase = _tc => {
  const doc = new Y.Doc({ gc: false })
  doc.getArray('array').insert(0, ['item1'])
  doc.getArray('array').delete(0)
@@ -111,9 +123,9 @@ export const testDeletedItemsBase = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testDeletedItems2 = tc => {
+export const testDeletedItems2 = _tc => {
  const doc = new Y.Doc({ gc: false })
  doc.getArray('array').insert(0, ['item1', 'item2', 'item3'])
  doc.getArray('array').delete(1)
@@ -169,3 +181,28 @@ export const testDependentChanges = tc => {
  const docRestored1 = Y.createDocFromSnapshot(array1.doc, snap)
  t.compare(docRestored1.getArray('array').toArray(), ['user1item1', 'user2item1'])
 }
+
+/**
+ * @param {t.TestCase} _tc
+ */
+export const testContainsUpdate = _tc => {
+  const ydoc = new Y.Doc()
+  /**
+   * @type {Array<Uint8Array>}
+   */
+  const updates = []
+  ydoc.on('update', update => {
+    updates.push(update)
+  })
+  const yarr = ydoc.getArray()
+  const snapshot1 = Y.snapshot(ydoc)
+  yarr.insert(0, [1])
+  const snapshot2 = Y.snapshot(ydoc)
+  yarr.delete(0, 1)
+  const snapshotFinal = Y.snapshot(ydoc)
+  t.assert(!Y.snapshotContainsUpdate(snapshot1, updates[0]))
+  t.assert(!Y.snapshotContainsUpdate(snapshot2, updates[1]))
+  t.assert(Y.snapshotContainsUpdate(snapshot2, updates[0]))
+  t.assert(Y.snapshotContainsUpdate(snapshotFinal, updates[0]))
+  t.assert(Y.snapshotContainsUpdate(snapshotFinal, updates[1]))
+}
--- a/tests/testHelper.js
+++ b/tests/testHelper.js
@@ -5,6 +5,7 @@ import * as encoding from 'lib0/encoding'
 import * as decoding from 'lib0/decoding'
 import * as syncProtocol from 'y-protocols/sync'
 import * as object from 'lib0/object'
+import * as map from 'lib0/map'
 import * as Y from '../src/index.js'
 export * from '../src/index.js'

@@ -89,8 +90,8 @@ export class TestYInstance extends Y.Doc {
        const encoder = encoding.createEncoder()
        syncProtocol.writeUpdate(encoder, update)
        broadcastMessage(this, encoding.toUint8Array(encoder))
-        this.updates.push(update)
      }
+      this.updates.push(update)
    })
    this.connect()
  }
@@ -133,12 +134,7 @@ export class TestYInstance extends Y.Doc {
   * @param {TestYInstance} remoteClient
   */
  _receive (message, remoteClient) {
-    let messages = this.receiving.get(remoteClient)
-    if (messages === undefined) {
-      messages = []
-      this.receiving.set(remoteClient, messages)
-    }
-    messages.push(message)
+    map.setIfUndefined(this.receiving, remoteClient, () => /** @type {Array<Uint8Array>} */ ([])).push(message)
  }
 }

@@ -202,17 +198,6 @@ export class TestConnector {
        // send reply message
        sender._receive(encoding.toUint8Array(encoder), receiver)
      }
-      {
-        // If update message, add the received message to the list of received messages
-        const decoder = decoding.createDecoder(m)
-        const messageType = decoding.readVarUint(decoder)
-        switch (messageType) {
-          case syncProtocol.messageYjsUpdate:
-          case syncProtocol.messageYjsSyncStep2:
-            receiver.updates.push(decoding.readVarUint8Array(decoder))
-            break
-        }
-      }
      return true
    }
    return false
@@ -362,7 +347,7 @@ export const compare = users => {
    t.compare(userMapValues[i], userMapValues[i + 1])
    t.compare(userXmlValues[i], userXmlValues[i + 1])
    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], '', (constructor, a, b) => {
+    t.compare(userTextValues[i], userTextValues[i + 1], '', (_constructor, a, b) => {
      if (a instanceof Y.AbstractType) {
        t.compare(a.toJSON(), b.toJSON())
      } else if (a !== b) {
@@ -371,8 +356,9 @@ export const compare = users => {
      return true
    })
    t.compare(Y.encodeStateVector(users[i]), Y.encodeStateVector(users[i + 1]))
-    compareDS(Y.createDeleteSetFromStructStore(users[i].store), Y.createDeleteSetFromStructStore(users[i + 1].store))
+    Y.equalDeleteSets(Y.createDeleteSetFromStructStore(users[i].store), Y.createDeleteSetFromStructStore(users[i + 1].store))
    compareStructStores(users[i].store, users[i + 1].store)
+    t.compare(Y.encodeSnapshot(Y.snapshot(users[i])), Y.encodeSnapshot(Y.snapshot(users[i + 1])))
  }
  users.map(u => u.destroy())
 }
@@ -385,8 +371,8 @@ export const compare = users => {
 export const compareItemIDs = (a, b) => a === b || (a !== null && b != null && Y.compareIDs(a.id, b.id))

 /**
- * @param {import('../src/internals').StructStore} ss1
- * @param {import('../src/internals').StructStore} ss2
+ * @param {import('../src/internals.js').StructStore} ss1
+ * @param {import('../src/internals.js').StructStore} ss2
 */
 export const compareStructStores = (ss1, ss2) => {
  t.assert(ss1.clients.size === ss2.clients.size)
@@ -427,25 +413,6 @@ export const compareStructStores = (ss1, ss2) => {
  }
 }

-/**
- * @param {import('../src/internals').DeleteSet} ds1
- * @param {import('../src/internals').DeleteSet} ds2
- */
-export const compareDS = (ds1, ds2) => {
-  t.assert(ds1.clients.size === ds2.clients.size)
-  ds1.clients.forEach((deleteItems1, client) => {
-    const deleteItems2 = /** @type {Array<import('../src/internals').DeleteItem>} */ (ds2.clients.get(client))
-    t.assert(deleteItems2 !== undefined && deleteItems1.length === deleteItems2.length)
-    for (let i = 0; i < deleteItems1.length; i++) {
-      const di1 = deleteItems1[i]
-      const di2 = deleteItems2[i]
-      if (di1.clock !== di2.clock || di1.len !== di2.len) {
-        t.fail('DeleteSets dont match')
-      }
-    }
-  })
-}
-
 /**
 * @template T
 * @callback InitTestObjectCallback
--- a/tests/undo-redo.tests.js
+++ b/tests/undo-redo.tests.js
@@ -1,8 +1,21 @@
-import { init, compare, applyRandomTests, Doc } from './testHelper.js' // eslint-disable-line
+import { init } from './testHelper.js' // eslint-disable-line

 import * as Y from '../src/index.js'
 import * as t from 'lib0/testing'

+/**
+ * @param {t.TestCase} tc
+ */
+export const testInfiniteCaptureTimeout = tc => {
+  const { array0 } = init(tc, { users: 3 })
+  const undoManager = new Y.UndoManager(array0, { captureTimeout: Number.MAX_VALUE })
+  array0.push([1, 2, 3])
+  undoManager.stopCapturing()
+  array0.push([4, 5, 6])
+  undoManager.undo()
+  t.compare(array0.toArray(), [1, 2, 3])
+}
+
 /**
 * @param {t.TestCase} tc
 */
@@ -51,9 +64,23 @@ export const testUndoText = tc => {

 /**
 * Test case to fix #241
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testDoubleUndo = tc => {
+export const testEmptyTypeScope = _tc => {
+  const ydoc = new Y.Doc()
+  const um = new Y.UndoManager([], { doc: ydoc })
+  const yarray = ydoc.getArray()
+  um.addToScope(yarray)
+  yarray.insert(0, [1])
+  um.undo()
+  t.assert(yarray.length === 0)
+}
+
+/**
+ * Test case to fix #241
+ * @param {t.TestCase} _tc
+ */
+export const testDoubleUndo = _tc => {
  const doc = new Y.Doc()
  const text = doc.getText()
  text.insert(0, '1221')
@@ -273,7 +300,7 @@ export const testUndoInEmbed = tc => {
 */
 export const testUndoDeleteFilter = tc => {
  /**
-   * @type {Array<Y.Map<any>>}
+   * @type {Y.Array<any>}
   */
  const array0 = /** @type {any} */ (init(tc, { users: 3 }).array0)
  const undoManager = new Y.UndoManager(array0, { deleteFilter: item => !(item instanceof Y.Item) || (item.content instanceof Y.ContentType && item.content.type._map.size === 0) })
@@ -289,9 +316,9 @@ export const testUndoDeleteFilter = tc => {

 /**
 * This issue has been reported in https://discuss.yjs.dev/t/undomanager-with-external-updates/454/6
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testUndoUntilChangePerformed = tc => {
+export const testUndoUntilChangePerformed = _tc => {
  const doc = new Y.Doc()
  const doc2 = new Y.Doc()
  doc.on('update', update => Y.applyUpdate(doc2, update))
@@ -320,9 +347,9 @@ export const testUndoUntilChangePerformed = tc => {

 /**
 * This issue has been reported in https://github.com/yjs/yjs/issues/317
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testUndoNestedUndoIssue = tc => {
+export const testUndoNestedUndoIssue = _tc => {
  const doc = new Y.Doc({ gc: false })
  const design = doc.getMap()
  const undoManager = new Y.UndoManager(design, { captureTimeout: 0 })
@@ -372,3 +399,279 @@ export const testUndoNestedUndoIssue = tc => {
  undoManager.redo()
  t.compare(design.toJSON(), { text: { blocks: { text: 'Something Else' } } })
 }
+
+/**
+ * This issue has been reported in https://github.com/yjs/yjs/issues/355
+ *
+ * @param {t.TestCase} _tc
+ */
+export const testConsecutiveRedoBug = _tc => {
+  const doc = new Y.Doc()
+  const yRoot = doc.getMap()
+  const undoMgr = new Y.UndoManager(yRoot)
+
+  let yPoint = new Y.Map()
+  yPoint.set('x', 0)
+  yPoint.set('y', 0)
+  yRoot.set('a', yPoint)
+  undoMgr.stopCapturing()
+
+  yPoint.set('x', 100)
+  yPoint.set('y', 100)
+  undoMgr.stopCapturing()
+
+  yPoint.set('x', 200)
+  yPoint.set('y', 200)
+  undoMgr.stopCapturing()
+
+  yPoint.set('x', 300)
+  yPoint.set('y', 300)
+  undoMgr.stopCapturing()
+
+  t.compare(yPoint.toJSON(), { x: 300, y: 300 })
+
+  undoMgr.undo() // x=200, y=200
+  t.compare(yPoint.toJSON(), { x: 200, y: 200 })
+  undoMgr.undo() // x=100, y=100
+  t.compare(yPoint.toJSON(), { x: 100, y: 100 })
+  undoMgr.undo() // x=0, y=0
+  t.compare(yPoint.toJSON(), { x: 0, y: 0 })
+  undoMgr.undo() // nil
+  t.compare(yRoot.get('a'), undefined)
+
+  undoMgr.redo() // x=0, y=0
+  yPoint = yRoot.get('a')
+
+  t.compare(yPoint.toJSON(), { x: 0, y: 0 })
+  undoMgr.redo() // x=100, y=100
+  t.compare(yPoint.toJSON(), { x: 100, y: 100 })
+  undoMgr.redo() // x=200, y=200
+  t.compare(yPoint.toJSON(), { x: 200, y: 200 })
+  undoMgr.redo() // expected x=300, y=300, actually nil
+  t.compare(yPoint.toJSON(), { x: 300, y: 300 })
+}
+
+/**
+ * This issue has been reported in https://github.com/yjs/yjs/issues/304
+ *
+ * @param {t.TestCase} _tc
+ */
+export const testUndoXmlBug = _tc => {
+  const origin = 'origin'
+  const doc = new Y.Doc()
+  const fragment = doc.getXmlFragment('t')
+  const undoManager = new Y.UndoManager(fragment, {
+    captureTimeout: 0,
+    trackedOrigins: new Set([origin])
+  })
+
+  // create element
+  doc.transact(() => {
+    const e = new Y.XmlElement('test-node')
+    e.setAttribute('a', '100')
+    e.setAttribute('b', '0')
+    fragment.insert(fragment.length, [e])
+  }, origin)
+
+  // change one attribute
+  doc.transact(() => {
+    const e = fragment.get(0)
+    e.setAttribute('a', '200')
+  }, origin)
+
+  // change both attributes
+  doc.transact(() => {
+    const e = fragment.get(0)
+    e.setAttribute('a', '180')
+    e.setAttribute('b', '50')
+  }, origin)
+
+  undoManager.undo()
+  undoManager.undo()
+  undoManager.undo()
+
+  undoManager.redo()
+  undoManager.redo()
+  undoManager.redo()
+  t.compare(fragment.toString(), '<test-node a="180" b="50"></test-node>')
+}
+
+/**
+ * This issue has been reported in https://github.com/yjs/yjs/issues/343
+ *
+ * @param {t.TestCase} _tc
+ */
+export const testUndoBlockBug = _tc => {
+  const doc = new Y.Doc({ gc: false })
+  const design = doc.getMap()
+
+  const undoManager = new Y.UndoManager(design, { captureTimeout: 0 })
+
+  const text = new Y.Map()
+
+  const blocks1 = new Y.Array()
+  const blocks1block = new Y.Map()
+  doc.transact(() => {
+    blocks1block.set('text', '1')
+    blocks1.push([blocks1block])
+
+    text.set('blocks', blocks1block)
+    design.set('text', text)
+  })
+
+  const blocks2 = new Y.Array()
+  const blocks2block = new Y.Map()
+  doc.transact(() => {
+    blocks2block.set('text', '2')
+    blocks2.push([blocks2block])
+    text.set('blocks', blocks2block)
+  })
+
+  const blocks3 = new Y.Array()
+  const blocks3block = new Y.Map()
+  doc.transact(() => {
+    blocks3block.set('text', '3')
+    blocks3.push([blocks3block])
+    text.set('blocks', blocks3block)
+  })
+
+  const blocks4 = new Y.Array()
+  const blocks4block = new Y.Map()
+  doc.transact(() => {
+    blocks4block.set('text', '4')
+    blocks4.push([blocks4block])
+    text.set('blocks', blocks4block)
+  })
+
+  // {"text":{"blocks":{"text":"4"}}}
+  undoManager.undo() // {"text":{"blocks":{"3"}}}
+  undoManager.undo() // {"text":{"blocks":{"text":"2"}}}
+  undoManager.undo() // {"text":{"blocks":{"text":"1"}}}
+  undoManager.undo() // {}
+  undoManager.redo() // {"text":{"blocks":{"text":"1"}}}
+  undoManager.redo() // {"text":{"blocks":{"text":"2"}}}
+  undoManager.redo() // {"text":{"blocks":{"text":"3"}}}
+  undoManager.redo() // {"text":{}}
+  t.compare(design.toJSON(), { text: { blocks: { text: '4' } } })
+}
+
+/**
+ * Undo text formatting delete should not corrupt peer state.
+ *
+ * @see https://github.com/yjs/yjs/issues/392
+ * @param {t.TestCase} _tc
+ */
+export const testUndoDeleteTextFormat = _tc => {
+  const doc = new Y.Doc()
+  const text = doc.getText()
+  text.insert(0, 'Attack ships on fire off the shoulder of Orion.')
+  const doc2 = new Y.Doc()
+  const text2 = doc2.getText()
+  Y.applyUpdate(doc2, Y.encodeStateAsUpdate(doc))
+  const undoManager = new Y.UndoManager(text)
+
+  text.format(13, 7, { bold: true })
+  undoManager.stopCapturing()
+  Y.applyUpdate(doc2, Y.encodeStateAsUpdate(doc))
+
+  text.format(16, 4, { bold: null })
+  undoManager.stopCapturing()
+  Y.applyUpdate(doc2, Y.encodeStateAsUpdate(doc))
+
+  undoManager.undo()
+  Y.applyUpdate(doc2, Y.encodeStateAsUpdate(doc))
+
+  const expect = [
+    { insert: 'Attack ships ' },
+    {
+      insert: 'on fire',
+      attributes: { bold: true }
+    },
+    { insert: ' off the shoulder of Orion.' }
+  ]
+  t.compare(text.toDelta(), expect)
+  t.compare(text2.toDelta(), expect)
+}
+
+/**
+ * Undo text formatting delete should not corrupt peer state.
+ *
+ * @see https://github.com/yjs/yjs/issues/392
+ * @param {t.TestCase} _tc
+ */
+export const testBehaviorOfIgnoreremotemapchangesProperty = _tc => {
+  const doc = new Y.Doc()
+  const doc2 = new Y.Doc()
+  doc.on('update', update => Y.applyUpdate(doc2, update, doc))
+  doc2.on('update', update => Y.applyUpdate(doc, update, doc2))
+  const map1 = doc.getMap()
+  const map2 = doc2.getMap()
+  const um1 = new Y.UndoManager(map1, { ignoreRemoteMapChanges: true })
+  map1.set('x', 1)
+  map2.set('x', 2)
+  map1.set('x', 3)
+  map2.set('x', 4)
+  um1.undo()
+  t.assert(map1.get('x') === 2)
+  t.assert(map2.get('x') === 2)
+}
+
+/**
+ * Special deletion case.
+ *
+ * @see https://github.com/yjs/yjs/issues/447
+ * @param {t.TestCase} _tc
+ */
+export const testSpecialDeletionCase = _tc => {
+  const origin = 'undoable'
+  const doc = new Y.Doc()
+  const fragment = doc.getXmlFragment()
+  const undoManager = new Y.UndoManager(fragment, { trackedOrigins: new Set([origin]) })
+  doc.transact(() => {
+    const e = new Y.XmlElement('test')
+    e.setAttribute('a', '1')
+    e.setAttribute('b', '2')
+    fragment.insert(0, [e])
+  })
+  t.compareStrings(fragment.toString(), '<test a="1" b="2"></test>')
+  doc.transact(() => {
+    // change attribute "b" and delete test-node
+    const e = fragment.get(0)
+    e.setAttribute('b', '3')
+    fragment.delete(0)
+  }, origin)
+  t.compareStrings(fragment.toString(), '')
+  undoManager.undo()
+  t.compareStrings(fragment.toString(), '<test a="1" b="2"></test>')
+}
+
+/**
+ * Deleted entries in a map should be restored on undo.
+ *
+ * @see https://github.com/yjs/yjs/issues/500
+ * @param {t.TestCase} tc
+ */
+export const testUndoDeleteInMap = (tc) => {
+  const { map0 } = init(tc, { users: 3 })
+  const undoManager = new Y.UndoManager(map0, { captureTimeout: 0 })
+  map0.set('a', 'a')
+  map0.delete('a')
+  map0.set('a', 'b')
+  map0.delete('a')
+  map0.set('a', 'c')
+  map0.delete('a')
+  map0.set('a', 'd')
+  t.compare(map0.toJSON(), { a: 'd' })
+  undoManager.undo()
+  t.compare(map0.toJSON(), {})
+  undoManager.undo()
+  t.compare(map0.toJSON(), { a: 'c' })
+  undoManager.undo()
+  t.compare(map0.toJSON(), {})
+  undoManager.undo()
+  t.compare(map0.toJSON(), { a: 'b' })
+  undoManager.undo()
+  t.compare(map0.toJSON(), {})
+  undoManager.undo()
+  t.compare(map0.toJSON(), { a: 'a' })
+}
--- a/tests/updates.tests.js
+++ b/tests/updates.tests.js
@@ -4,6 +4,7 @@ import * as Y from '../src/index.js'
 import { readClientsStructRefs, readDeleteSet, UpdateDecoderV2, UpdateEncoderV2, writeDeleteSet } from '../src/internals.js'
 import * as encoding from 'lib0/encoding'
 import * as decoding from 'lib0/decoding'
+import * as object from 'lib0/object'

 /**
 * @typedef {Object} Enc
@@ -112,6 +113,24 @@ export const testMergeUpdates = tc => {
  })
 }

+/**
+ * @param {t.TestCase} tc
+ */
+export const testKeyEncoding = tc => {
+  const { users, text0, text1 } = init(tc, { users: 2 })
+
+  text0.insert(0, 'a', { italic: true })
+  text0.insert(0, 'b')
+  text0.insert(0, 'c', { italic: true })
+
+  const update = Y.encodeStateAsUpdateV2(users[0])
+  Y.applyUpdateV2(users[1], update)
+
+  t.compare(text1.toDelta(), [{ insert: 'c', attributes: { italic: true } }, { insert: 'b' }, { insert: 'a', attributes: { italic: true } }])
+
+  compare(users)
+}
+
 /**
 * @param {Y.Doc} ydoc
 * @param {Array<Uint8Array>} updates - expecting at least 4 updates
@@ -120,7 +139,6 @@ export const testMergeUpdates = tc => {
 */
 const checkUpdateCases = (ydoc, updates, enc, hasDeletes) => {
  const cases = []
-
  // Case 1: Simple case, simply merge everything
  cases.push(enc.mergeUpdates(updates))

@@ -286,3 +304,54 @@ export const testMergePendingUpdates = tc => {
  const yText5 = yDoc5.getText('textBlock')
  t.compareStrings(yText5.toString(), 'nenor')
 }
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testObfuscateUpdates = tc => {
+  const ydoc = new Y.Doc()
+  const ytext = ydoc.getText('text')
+  const ymap = ydoc.getMap('map')
+  const yarray = ydoc.getArray('array')
+  // test ytext
+  ytext.applyDelta([{ insert: 'text', attributes: { bold: true } }, { insert: { href: 'supersecreturl' } }])
+  // test ymap
+  ymap.set('key', 'secret1')
+  ymap.set('key', 'secret2')
+  // test yarray with subtype & subdoc
+  const subtype = new Y.XmlElement('secretnodename')
+  const subdoc = new Y.Doc({ guid: 'secret' })
+  subtype.setAttribute('attr', 'val')
+  yarray.insert(0, ['teststring', 42, subtype, subdoc])
+  // obfuscate the content and put it into a new document
+  const obfuscatedUpdate = Y.obfuscateUpdate(Y.encodeStateAsUpdate(ydoc))
+  const odoc = new Y.Doc()
+  Y.applyUpdate(odoc, obfuscatedUpdate)
+  const otext = odoc.getText('text')
+  const omap = odoc.getMap('map')
+  const oarray = odoc.getArray('array')
+  // test ytext
+  const delta = otext.toDelta()
+  t.assert(delta.length === 2)
+  t.assert(delta[0].insert !== 'text' && delta[0].insert.length === 4)
+  t.assert(object.length(delta[0].attributes) === 1)
+  t.assert(!object.hasProperty(delta[0].attributes, 'bold'))
+  t.assert(object.length(delta[1]) === 1)
+  t.assert(object.hasProperty(delta[1], 'insert'))
+  // test ymap
+  t.assert(omap.size === 1)
+  t.assert(!omap.has('key'))
+  // test yarray with subtype & subdoc
+  const result = oarray.toArray()
+  t.assert(result.length === 4)
+  t.assert(result[0] !== 'teststring')
+  t.assert(result[1] !== 42)
+  const osubtype = /** @type {Y.XmlElement} */ (result[2])
+  const osubdoc = result[3]
+  // test subtype
+  t.assert(osubtype.nodeName !== subtype.nodeName)
+  t.assert(object.length(osubtype.getAttributes()) === 1)
+  t.assert(osubtype.getAttribute('attr') === undefined)
+  // test subdoc
+  t.assert(osubdoc.guid !== subdoc.guid)
+}
--- a/tests/y-array.tests.js
+++ b/tests/y-array.tests.js
@@ -32,6 +32,17 @@ export const testSlice = tc => {
  t.compareArrays(arr.slice(0, 2), [0, 1])
 }

+/**
+ * @param {t.TestCase} tc
+ */
+export const testArrayFrom = tc => {
+  const doc1 = new Y.Doc()
+  const db1 = doc1.getMap('root')
+  const nestedArray1 = Y.Array.from([0, 1, 2])
+  db1.set('array', nestedArray1)
+  t.compare(nestedArray1.toArray(), [0, 1, 2])
+}
+
 /**
 * Debugging yjs#297 - a critical bug connected to the search-marker approach
 *
--- a/tests/y-map.tests.js
+++ b/tests/y-map.tests.js
@@ -455,9 +455,9 @@ export const testChangeEvent = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testYmapEventExceptionsShouldCompleteTransaction = tc => {
+export const testYmapEventExceptionsShouldCompleteTransaction = _tc => {
  const doc = new Y.Doc()
  const map = doc.getMap('map')

--- a/tests/y-text.tests.js
+++ b/tests/y-text.tests.js
--- a/tests/y-xml.tests.js
+++ b/tests/y-xml.tests.js
@@ -3,6 +3,33 @@ import * as Y from '../src/index.js'

 import * as t from 'lib0/testing'

+export const testCustomTypings = () => {
+  const ydoc = new Y.Doc()
+  const ymap = ydoc.getMap()
+  /**
+   * @type {Y.XmlElement<{ num: number, str: string, [k:string]: object|number|string }>}
+   */
+  const yxml = ymap.set('yxml', new Y.XmlElement('test'))
+  /**
+   * @type {number|undefined}
+   */
+  const num = yxml.getAttribute('num')
+  /**
+   * @type {string|undefined}
+   */
+  const str = yxml.getAttribute('str')
+  /**
+   * @type {object|number|string|undefined}
+   */
+  const dtrn = yxml.getAttribute('dtrn')
+  const attrs = yxml.getAttributes()
+  /**
+   * @type {object|number|string|undefined}
+   */
+  const any = attrs.shouldBeAny
+  console.log({ num, str, dtrn, attrs, any })
+}
+
 /**
 * @param {t.TestCase} tc
 */
@@ -92,9 +119,9 @@ export const testTreewalker = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testYtextAttributes = tc => {
+export const testYtextAttributes = _tc => {
  const ydoc = new Y.Doc()
  const ytext = /** @type {Y.XmlText} */ (ydoc.get('', Y.XmlText))
  ytext.observe(event => {
@@ -106,9 +133,9 @@ export const testYtextAttributes = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testSiblings = tc => {
+export const testSiblings = _tc => {
  const ydoc = new Y.Doc()
  const yxml = ydoc.getXmlFragment()
  const first = new Y.XmlText()
@@ -122,9 +149,9 @@ export const testSiblings = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testInsertafter = tc => {
+export const testInsertafter = _tc => {
  const ydoc = new Y.Doc()
  const yxml = ydoc.getXmlFragment()
  const first = new Y.XmlText()
@@ -152,9 +179,9 @@ export const testInsertafter = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testClone = tc => {
+export const testClone = _tc => {
  const ydoc = new Y.Doc()
  const yxml = ydoc.getXmlFragment()
  const first = new Y.XmlText('text')
@@ -170,9 +197,9 @@ export const testClone = tc => {
 }

 /**
- * @param {t.TestCase} tc
+ * @param {t.TestCase} _tc
 */
-export const testFormattingBug = tc => {
+export const testFormattingBug = _tc => {
  const ydoc = new Y.Doc()
  const yxml = /** @type {Y.XmlText} */ (ydoc.get('', Y.XmlText))
  const delta = [
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,64 +1,21 @@
 {
  "compilerOptions": {
-    /* Basic Options */
-    "target": "es2018",
-    "lib": ["es2018", "dom"],                             /* Specify library files to be included in the compilation. */
-    "allowJs": true,                       /* Allow javascript files to be compiled. */
-    "checkJs": true,                       /* Report errors in .js files. */
-    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-    "declaration": true,                   /* Generates corresponding '.d.ts' file. */
-    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
-    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
-    // "outFile": "./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. */
-    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
-    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-
-    /* Strict Type-Checking Options */
-    "strict": true,                           /* Enable all strict type-checking options. */
-    "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    "target": "ES2021",
+    "lib": ["ES2021", "dom"],
+    "module": "node16",
+    "allowJs": true,
+    "checkJs": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
    "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. */
-    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
-    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-
-    /* Additional Checks */
-    // "noUnusedLocals": true,                /* Report errors on unused locals. */
-    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
-    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
-    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-
-    /* Module Resolution Options */
-    "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    "strict": true,
+    "noImplicitAny": true,
+    "moduleResolution": "nodenext",
    "paths": {
      "yjs": ["./src/index.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. */
-    // "types": [],                           /* Type declaration files to be included in compilation. */
-    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true,                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
-
-    /* Source Map Options */
-    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
-    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-
-    /* Experimental Options */
-    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
-    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
-    // "maxNodeModuleJsDepth": 0,
-    // "types": ["./src/utils/typedefs.js"]
+    }
  },
  "include": ["./src/**/*.js", "./tests/**/*.js"]
 }
Author	SHA1	Message	Date
Kevin Jahns	00ef472d68	13.6.2	2023-06-08 11:19:06 +02:00
Kevin Jahns	719858201a	implement snapshotContainsUpdate	2023-06-08 11:14:49 +02:00
Kevin Jahns	5db1eed181	Merge pull request #528 from jamesgpearce/patch-1 Add missing getting-started steps	2023-05-05 12:21:56 +02:00
Kevin Jahns	2e9a648d08	13.6.1	2023-05-04 11:29:08 +02:00
Kevin Jahns	83712cb1a6	update typings of getAttributes	2023-05-04 11:26:11 +02:00
Kevin Jahns	30b56d5ae9	Enable typings for inserting custom attrs in YXmlElement - fixes #531	2023-05-04 10:07:05 +02:00
James Pearce	61eeaef226	Add missing getting-started steps	2023-04-30 16:31:46 -04:00
Kevin Jahns	adaa95ebb8	add example to createDocFromSnapshot - #159	2023-04-27 18:08:28 +02:00
Kevin Jahns	1f2f08ef7e	13.6.0	2023-04-22 18:41:44 +02:00
Kevin Jahns	39167e6e2a	Implement function that obfuscates a ydoc and scrambles its content	2023-04-22 18:39:29 +02:00
Kevin Jahns	5a8519d2c2	13.5.53	2023-04-18 20:09:59 +02:00
Kevin Jahns	d039d48b3f	ytext: diff should never create useless delta op	2023-04-18 20:07:17 +02:00
Kevin Jahns	710ac31af3	13.5.52	2023-04-03 14:12:34 +02:00
Kevin Jahns	49f435284f	lint	2023-04-03 14:10:26 +02:00
Kevin Jahns	ba96f2fe74	implement fix for #500 . extends #515	2023-04-03 14:02:37 +02:00
Dominik Henneke	99bab4a1d8	Fix lint errors	2023-04-03 14:02:37 +02:00
Dominik Henneke	1674d3986d	Restore deleted entries in a map	2023-04-03 14:02:37 +02:00
Kevin Jahns	dc3e99e6a1	Merge pull request #518 from WofWca/jsdoc-yarray docs: fix JSDoc typo	2023-04-02 11:47:46 +02:00
WofWca	fb6664a2bc	docs: fix JSDoc typo	2023-04-01 23:12:49 +08:00
Kevin Jahns	0d7e865531	13.5.51	2023-03-22 11:05:23 +01:00
Kevin Jahns	e73eb0bf92	use lib0 conditional exports in cjs file	2023-03-22 11:02:55 +01:00
Kevin Jahns	d815855450	specify engine	2023-03-21 11:27:37 +01:00
Kevin Jahns	61ba6cdde1	bump ci to use current nodejs versions	2023-03-21 11:22:59 +01:00
Kevin Jahns	cb70d7bad3	fix typings and lib0 resolution	2023-03-21 11:14:37 +01:00
Kevin Jahns	2001bec8eb	modernize tsconfig	2023-03-11 12:20:52 +01:00
Kevin Jahns	2e2710ded9	13.5.50	2023-03-11 09:15:11 +01:00
Kevin Jahns	227018f5c7	toDelta doesnt create transaction - fixes #506	2023-03-11 09:13:27 +01:00
Kevin Jahns	da8bacfc78	add tests for complex Y.Text deltas	2023-03-10 12:53:48 +01:00
Kevin Jahns	92bad63145	add docs: tr.changes should only be computed during the event	2023-03-09 18:44:43 +01:00
Kevin Jahns	52ff230dd1	13.5.49	2023-03-09 13:59:08 +01:00
Kevin Jahns	fe48efe64f	fix generating too many cleanup transactions. closes #506	2023-03-09 13:45:13 +01:00
Kevin Jahns	7e40fc442d	13.5.48	2023-03-02 19:50:34 +01:00
Kevin Jahns	035e350062	optimize formatting cleanup	2023-03-02 19:48:00 +01:00
Kevin Jahns	bf338d8040	fix attribute update issue - fixes #503	2023-03-02 19:08:01 +01:00
Kevin Jahns	658c520b93	13.5.47	2023-02-21 14:37:24 +01:00
Kevin Jahns	2576d4efca	increasing sort of ds encoding	2023-02-21 14:35:28 +01:00
Kevin Jahns	58b754950e	Merge pull request #439 from Synthesia-Technologies/feat/deterministic-update-encoding Make encodeStateAsUpdate deterministic	2023-02-21 10:59:31 +01:00
Kevin Jahns	ea7ad07f34	13.5.46	2023-02-14 16:21:01 +01:00
Kevin Jahns	1c999b250e	fix #474 - formatting bug	2023-02-14 16:19:22 +01:00
Kevin Jahns	e9189365ee	add debugging case for #474 - unfininished	2023-02-13 14:27:57 +01:00
Kevin Jahns	e0a2f11db3	13.5.45	2023-01-31 12:57:56 +01:00
Kevin Jahns	7445a9ce5f	add whenSynced and isSynced property with refined logic	2023-01-31 12:56:07 +01:00
Kevin Jahns	7f6c12a541	bump typescript and fix type issues	2023-01-31 12:16:03 +01:00
Kevin Jahns	370d0c138d	Merge pull request #496 from neftaly/array.from Add test for Y.Array.from	2023-01-25 13:12:52 +01:00
Neftaly Hernandez	d29de75f85	Add test for Y.Array.from	2023-01-23 06:41:57 +00:00
Kevin Jahns	f215866429	remove poxi on request..	2023-01-19 15:24:53 +01:00
Kevin Jahns	093b41ccc4	Merge pull request #495 from laem/patch-1 New user	2023-01-19 15:20:41 +01:00
Mael	ab60cd1ff8	New user	2023-01-19 15:06:20 +01:00
Kevin Jahns	1130abe05b	add POXi as a user	2023-01-18 12:20:52 +01:00
Kevin Jahns	31b4ab8d0c	13.5.44	2023-01-01 18:25:03 +01:00
Kevin Jahns	ab978b2003	add exports.module field - #438	2023-01-01 18:23:21 +01:00
Kevin Jahns	afc6728c9e	13.5.43	2022-11-30 12:28:28 +01:00
Kevin Jahns	0ef5bd42fe	lint readme	2022-11-30 12:26:55 +01:00
Kevin Jahns	3ece681758	allow transactions within event handlers having different origins	2022-11-30 12:09:19 +01:00
Kevin Jahns	cac9407185	remove snapshot param in yxml.getAttributes	2022-11-30 11:34:34 +01:00
Kevin Jahns	7ea8ffebae	Merge pull request #482 from joakim/patch-2 Add missing word	2022-11-08 16:30:12 +01:00
Joakim	d7751c16fd	Add missing word	2022-11-05 21:15:33 +01:00
Kevin Jahns	a64c51ec06	Merge pull request #478 from ViktorQvarfordt/patch-1 Add Sana to -Who Is Using Yjs-	2022-10-24 13:10:31 +02:00
Viktor Qvarfordt	7405057037	Add Sana to -Who Is Using Yjs-	2022-10-23 21:34:43 +02:00
Kevin Jahns	6208b82872	13.5.42	2022-10-18 16:52:38 +02:00
Kevin Jahns	12a9134b09	lint	2022-10-18 16:51:07 +02:00
Kevin Jahns	7395229086	Port test from @PatrickShaw #432 . Allow infinite captureTimeout in UndoManager #431 . Closes #432	2022-10-18 16:45:30 +02:00
Kevin Jahns	8fb73edd97	Merge pull request #453 from Cargo/main Allow updating captureTimeout on UndoManager instances	2022-10-03 11:58:03 +02:00
Kevin Jahns	f1ad5686c1	Add Hyperquery to -Who Is Using Yjs-	2022-10-02 17:10:14 +02:00
Kevin Jahns	ed9236bdc7	Merge pull request #464 from MaxNoetzold/main Add y-mongodb-provider to provider list in README	2022-09-26 22:08:43 +02:00
Kevin Jahns	5405fd2d7c	Merge pull request #465 from neo/patch-1 Remove unused return in `forEach` of `YMap`	2022-09-20 13:07:23 +02:00
Wenchen Li	12667f6b66	Remove unused return in `forEach` of `YMap` If the idea is to keep the API as close to the JS Map as possible, maybe we should consider not returning here. Ref: https://github.com/microsoft/TypeScript/blob/v4.8.3/lib/lib.es2015.collection.d.ts#L28-L31	2022-09-19 18:19:41 -04:00
MaxNoetzold	3d7ef7e28b	add y-mongodb-provider to provider list in README	2022-09-18 14:17:52 +02:00
Kevin Jahns	56267e0a7d	Merge pull request #455 from scenaristeur/patch-1 Update INTERNALS.md	2022-09-16 23:26:04 +02:00
Kevin Jahns	da71f6fa45	Merge pull request #463 from doodlewind/patch-1 add AFFiNE to sponsor list	2022-09-14 17:43:04 +02:00
Kevin Jahns	588788fbef	fix snapshot diff calculation naming bug	2022-09-14 00:37:06 +02:00
Yifeng Wang	fb9df6efe2	add AFFiNE to sponsor list	2022-09-13 21:31:10 +08:00
Kevin Jahns	a69ecb0287	Merge pull request #460 from regischen/fix-typo fix typo	2022-08-25 12:03:42 +02:00
regischen	923fc6e06e	fix typo	2022-08-25 17:35:24 +08:00
David	0fdfd93e4b	Update INTERNALS.md Typo	2022-08-14 10:10:14 +02:00
Aart Rost	e0e5f8d2ea	Allow updating captureTimeout on UndoManager instances Used to pause the undoManager by toggling the timeout with `yUndoManager.captureTimeout = Number.MAX_VALUE`	2022-08-10 14:07:40 -07:00
Kevin Jahns	daf034cf75	Merge pull request #452 from aryzing/patch-1 Update README.md	2022-08-08 10:57:13 +02:00
Eduard Bardají Puig	2157ebb4d0	Update README.md Add missing `.getText()` method to docs.	2022-08-07 20:52:16 +02:00
Kevin Jahns	97ef4ae1e0	13.5.41	2022-07-28 14:14:27 +02:00
Kevin Jahns	df2d59e2fb	UndoManager: fix special deletion case. closes #447 closes #443	2022-07-28 14:12:21 +02:00
Kevin Jahns	7a61c90261	13.5.40	2022-07-22 14:24:44 +02:00
Kevin Jahns	6fa8778fc7	add doc parameter to UndoManager	2022-07-22 14:22:46 +02:00
Adam Chelminski	6b7b3136e0	delete set encoding should be in descending order	2022-06-23 16:01:29 +02:00
Adam Chelminski	da052bdb0a	Make encodeStateAsUpdate deterministic	2022-06-23 15:50:35 +02:00
Kevin Jahns	1bc9308566	improve already-imported message further	2022-06-16 12:57:04 +02:00
Kevin Jahns	a5e0448a92	Merge pull request #434 from PatrickShaw/globalThis-add Prefer globalThis over window and global	2022-06-15 12:04:09 +02:00
Kevin Jahns	c0c2b3347b	13.5.39	2022-06-15 10:49:48 +02:00
Kevin Jahns	6258ba1ce9	Merge pull request #435 from yogas/export_UpdateEncoderV1 export UpdateEncoderV1	2022-06-15 10:47:04 +02:00
Vladimir Shapovalov	5a7ee74f68	export UpdateEncoderV1	2022-06-14 13:16:35 +07:00
Kevin Jahns	29fb4a0aab	improve double-import error message	2022-06-13 10:27:04 +02:00
Patrick Shaw	8937494bdd	Added globalThis	2022-06-01 13:36:32 +10:00
Kevin Jahns	4504196d5c	add gitter & discord link	2022-05-19 22:15:10 +02:00
Kevin Jahns	0c8d29bfff	Merge pull request #424 from KentoMoriwaki/patch-1 Add support for esm in node.js	2022-05-17 14:38:25 +02:00
Kento Moriwaki	43384e4148	Add support for esm in node.js	2022-05-17 21:18:04 +09:00
Kevin Jahns	a2b62b0a58	13.5.38	2022-05-14 18:11:57 +02:00
Kevin Jahns	6febf51b1a	fix captureTransaction	2022-05-14 18:10:19 +02:00
Kevin Jahns	5a4816a1b2	13.5.37	2022-05-14 14:25:28 +02:00
Kevin Jahns	4ad8af9a80	Add option to UndoManager to filter transactions	2022-05-14 14:23:47 +02:00
Kevin Jahns	fc25136b25	13.5.36	2022-05-09 12:55:19 +02:00
Kevin Jahns	ece1fe5426	minimize changes when formatting text - #422	2022-05-09 12:53:26 +02:00
Kevin Jahns	40196ae0a3	add slidebeamer as user	2022-04-27 16:33:00 +02:00
Kevin Jahns	bdefe0526d	13.5.35	2022-04-23 15:15:47 +02:00
Kevin Jahns	dbbb86adc7	bump dependencies	2022-04-23 15:14:05 +02:00
Kevin Jahns	1c9c97ffe6	add yxml.forEach method - closes #421	2022-04-23 15:13:26 +02:00
Kevin Jahns	14c14de21e	simplify testhelper	2022-04-20 18:01:33 +02:00
Kevin Jahns	71fad52854	fix typing information YMap.iterator - fixes #420	2022-04-20 13:09:56 +02:00
Kevin Jahns	3935ba1faa	update sponsors message	2022-04-18 19:12:41 +02:00
Kevin Jahns	4aacb487d2	complete documentation about relative positions	2022-04-17 16:03:20 +02:00
Kevin Jahns	5f56baa23e	remove circle-ci	2022-04-06 23:31:49 +02:00
Kevin Jahns	8d809ebacb	Adding Skiff as a user	2022-04-05 09:54:45 +02:00
Kevin Jahns	92624afbff	13.5.34	2022-04-04 16:23:21 +02:00
Kevin Jahns	1e8efd5104	bump lib0 for compatibility with y-crdt	2022-04-04 16:21:41 +02:00
Kevin Jahns	7b680f1bda	13.5.33	2022-03-30 14:55:10 +02:00
Kevin Jahns	806bf3f6dd	lint	2022-03-30 14:53:14 +02:00
Kevin Jahns	42fe19daf1	require updated lib0 dependency	2022-03-30 14:51:21 +02:00
Kevin Jahns	7d3de7fa07	add blocksurvey.io as a user	2022-03-28 10:50:48 +02:00
Kevin Jahns	63c1cb4eb9	bump dependencies	2022-03-28 10:38:54 +02:00
Kevin Jahns	be1449a7af	13.5.32	2022-03-26 10:31:13 +01:00
Kevin Jahns	a22b3cdbc1	add option to UndoManager to ignore remote map changes. implements #390	2022-03-26 10:29:19 +01:00
Kevin Jahns	e9a0dc4ed2	add destroy logic	2022-03-25 11:08:30 +01:00
Kevin Jahns	b0b276d964	13.5.31	2022-03-25 11:01:57 +01:00
Kevin Jahns	d3e117702c	add method to add & remove tracked origins	2022-03-25 11:00:07 +01:00
Kevin Jahns	ff5067e149	13.5.30	2022-03-22 09:47:10 +01:00
Kevin Jahns	f80e39a477	Merge pull request #408 from rileyjshaw/upgrade-lib0 Upgrade lib0 from v0.2.43 to v0.2.47	2022-03-22 09:43:41 +01:00
Riley Shaw	f70198333a	Upgrade lib0 from v0.2.43 to v0.2.47 After upgrading to the latest version (13.5.29), I started to see the following error: ``` ERROR in ./node_modules/yjs/dist/yjs.mjs 4048:13-26 export 'isArray' (imported as 'array') was not found in 'lib0/array' (possible exports: appendTo, copy, create, equalFlat, every, flatten, from, last, some) ``` It looks like `array.isArray` was added to `lib0` in [v0.2.47](https://github.com/dmonad/lib0/releases/tag/v0.2.47). Updating the version in `package.json` fixed the error in my project.	2022-03-21 19:16:23 -04:00
Kevin Jahns	3c31b22a92	13.5.29	2022-03-21 00:00:00 +01:00
Kevin Jahns	6b8cef29e2	address #398	2022-03-20 23:58:14 +01:00
Kevin Jahns	4a06492fb1	add stack-item-updated event to Y.UndoManager. implements #407	2022-03-20 22:49:23 +01:00
Kevin Jahns	46fbce0de8	more utility around Y.UndoManager	2022-03-20 22:41:33 +01:00
Kevin Jahns	239703fe5c	Merge pull request #401 from dylans/patch-1 Add Living Spec to readme	2022-03-19 13:22:10 +01:00
Kevin Jahns	5e907e3281	Merge pull request #404 from alderzhang/alder/issue-403 fix decodeUpdateV2 bug	2022-03-15 13:53:12 +01:00
alderzhang	6aea35246b	fix decodeUpdateV2 bug	2022-03-15 15:22:51 +08:00
Dylan Schiemann	5058189a46	Add Living Spec to readme We've sponsored via GitHub and OpenCollective for a while and have made a few contributions. We'd like to be added to the list of users if appropriate. Thanks.	2022-03-13 04:23:17 -07:00
Kevin Jahns	4db3439bb1	Merge pull request #397 from sep2/patch-1 add immer-yjs to Bindings	2022-03-09 22:06:56 +01:00
Felix	aa5463b06d	add immer-yjs to Bindings	2022-03-07 11:45:50 +08:00
Kevin Jahns	afe8e52840	13.5.28	2022-03-02 13:27:33 +01:00
Kevin Jahns	d0f9c4a27f	lint	2022-03-02 13:25:56 +01:00
Kevin Jahns	a5ffdce342	bump dependencies	2022-03-02 13:23:18 +01:00
Kevin Jahns	67d27dfca2	update readme	2022-03-02 13:19:00 +01:00
Kevin Jahns	9f1548204a	Merge pull request #376 from fson/yevent-target-type Add more accurate typing for YEvent.target	2022-03-02 13:18:00 +01:00
Kevin Jahns	46e108f345	Merge pull request #388 from sanalabs/uk/decode-methods Add decode methods	2022-03-01 15:16:59 +01:00
Kevin Jahns	bda622f523	Merge pull request #391 from Flamenco/patch-1 Fix typo	2022-03-01 15:15:58 +01:00
Kevin Jahns	fef9e39d91	Merge pull request #393 from dkuhnert/issue-392 cleanup redundant text attributes when delete attributes	2022-02-24 22:07:49 +01:00
Kevin Jahns	5751a12c11	add PRSM to projects	2022-02-24 14:45:17 +01:00
dkuhnert	fddb620d41	cleanup redundant text attributes when delete attributes fixes #392	2022-02-23 18:20:26 +01:00
dkuhnert	abf3fab1b6	cleanup redundant text attributes when delete attributes fixes #392	2022-02-23 14:53:31 +01:00
Flamenco	69e2375dc5	Fix typo	2022-02-18 08:15:45 -05:00
Kevin Jahns	058a50285c	add dynaboard to the list of projects	2022-02-16 21:15:19 +01:00
Ulf Karlsson	8678ef62d6	Remove curr.info	2022-02-07 20:00:10 +01:00
Ulf Karlsson	db53b6c720	Add decode methods	2022-02-07 17:15:06 +01:00
Kevin Jahns	3f34777201	13.5.27	2022-02-04 12:42:59 +01:00
Kevin Jahns	24eddb2d75	fix concurrent formatting / cleanup bug	2022-02-04 12:41:13 +01:00
Kevin Jahns	8ce107bd17	Merge branch 'ja2nicholl-update-attributes-on-delete'	2022-02-04 11:27:07 +01:00
Kevin Jahns	2d1e3fde43	fixed edge formatting case	2022-02-04 11:26:32 +01:00
Kevin Jahns	04009f0d42	Merge branch 'update-attributes-on-delete' of git://github.com/ja2nicholl/yjs into ja2nicholl-update-attributes-on-delete	2022-02-04 10:39:41 +01:00
Kevin Jahns	d69d93f812	13.5.26	2022-02-03 21:38:48 +01:00
Kevin Jahns	931a37a331	only fire stack-item-added when and item was actually added. closes #368	2022-02-03 21:36:54 +01:00
Kevin Jahns	0ec2753313	13.5.25	2022-02-03 21:27:16 +01:00
Kevin Jahns	8fd1f3405a	lint	2022-02-03 21:25:29 +01:00
Kevin Jahns	f577a8e3cf	Merge pull request #366 from holtwick/main Add canUndo/canRedo to UndoManager. Fixes #365	2022-02-03 21:21:33 +01:00
Jeremy Nicholl	84e95f11cb	Fix formatting	2022-02-03 15:19:57 -05:00
Kevin Jahns	f08682ddfd	Merge branch 'main' of github.com:yjs/yjs	2022-02-03 21:15:18 +01:00
Kevin Jahns	c20d72b886	Merge pull request #370 from doodlewind/typo fix minor typos	2022-02-03 21:14:02 +01:00
Kevin Jahns	c9414f51a7	Merge pull request #387 from YousefED/patch-3 Update README.md (syncedstore svelte)	2022-02-03 21:12:19 +01:00
Kevin Jahns	0fee9dfff4	remove sponsoring message	2022-02-03 21:11:40 +01:00
Kevin Jahns	4cfa49d601	reproduce and fix issues #355 #343 #304 and closes #367	2022-02-03 21:10:24 +01:00
Yousef	b6562f3e80	Update README.md	2022-02-01 16:54:06 +01:00
Jeremy Nicholl	164b38f0cd	Avoid copying attribute map when deleting Calling cleanupFormattingGap should not make a copy of the attributes because it needs to be able to update them.	2022-01-31 14:49:16 -05:00
Kevin Jahns	99326f67b8	Closes #377	2022-01-25 12:31:22 +01:00
Kevin Jahns	1c360f9f59	Merge pull request #383 from boschDev/main Update Pluxbox RadioManager location	2022-01-25 12:27:55 +01:00
Roeland Bosch	8f0d7cdfc2	Update Pluxbox RadioManager location	2022-01-24 16:55:02 +01:00
Kevin Jahns	b281277c67	Merge pull request #380 from carloslfu/patch-1 fix typo in README	2022-01-21 00:52:33 +01:00
Carlos Galarza	532d5fccb2	fix typo in README	2022-01-20 17:32:02 -05:00
Kevin Jahns	8f421a0f42	Merge pull request #378 from YousefED/patch-2 Update README.md (matrix-crdt)	2022-01-18 19:08:55 +01:00
Yousef	8fec835338	Update README.md	2022-01-18 18:41:06 +01:00
Ville Immonen	81a36a2762	add more accurate typing for YEvent.target	2022-01-15 14:22:17 +02:00
Kevin Jahns	6403bc2bb5	13.5.24	2022-01-11 21:55:31 +01:00
Kevin Jahns	20e1234af2	implement performant push in arrays	2022-01-11 21:53:20 +01:00
Kevin Jahns	3aebb8db83	correct typings for a test	2022-01-10 22:04:28 +01:00
Yifeng Wang	51bb732606	fix minor typos	2022-01-05 01:20:57 +08:00
Dirk Holtwick	f857345451	Add canUndo/canRedo to UndoManager. Fixes #365	2021-12-18 18:26:32 +01:00