@y/y 14.0.0-rc.2 → 14.0.0-rc.20

package/src/structs/Item.js

@@ -1,33 +1,20 @@
+import * as error from 'lib0/error'
+import * as binary from 'lib0/binary'
+import * as env from 'lib0/environment'
+import * as object from 'lib0/object'
+
+import { AbstractStruct, addStructToIdSet } from '../structs/AbstractStruct.js'
+
+import { ID, createID, compareIDs, findRootTypeKey } from '../utils/ID.js'
+import { GC } from '../structs/GC.js'
+
 import {
-  GC,
-  getState,
-  AbstractStruct,
   replaceStruct,
-  addStruct,
-  addToIdSet,
-  findRootTypeKey,
-  compareIDs,
-  getItem,
   getItemCleanEnd,
-  getItemCleanStart,
-  readContentDeleted,
-  readContentBinary,
-  readContentJSON,
-  readContentAny,
-  readContentString,
-  readContentEmbed,
-  readContentDoc,
-  createID,
-  readContentFormat,
-  readContentType,
-  addChangedTypeToTransaction,
-  addStructToIdSet,
-  IdSet, StackItem, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, ContentType, ContentDeleted, StructStore, ID, YType, Transaction, // eslint-disable-line
-} from '../internals.js'
+  addChangedTypeToTransaction
+} from '../utils/transaction-helpers.js'
 
-import * as error from 'lib0/error'
-import * as binary from 'lib0/binary'
-import * as array from 'lib0/array'
+const isDevMode = env.getVariable('node_env') === 'development'
 
 /**
  * @todo This should return several items
@@ -47,227 +34,15 @@ export const followRedone = (store, id) => {
     if (diff > 0) {
       nextID = createID(nextID.client, nextID.clock + diff)
     }
-    item = getItem(store, nextID)
+    item = store.getItem(nextID)
     diff = nextID.clock - item.id.clock
     nextID = item.redone
-  } while (nextID !== null && item instanceof Item)
+  } while (nextID !== null && item.isItem)
   return {
     item, diff
   }
 }
 
-/**
- * Make sure that neither item nor any of its parents is ever deleted.
- *
- * This property does not persist when storing it into a database or when
- * sending it to other peers
- *
- * @param {Item|null} item
- * @param {boolean} keep
- */
-export const keepItem = (item, keep) => {
-  while (item !== null && item.keep !== keep) {
-    item.keep = keep
-    item = /** @type {YType} */ (item.parent)._item
-  }
-}
-
-/**
- * Split leftItem into two items
- * @param {Transaction?} transaction
- * @param {Item} leftItem
- * @param {number} diff
- * @return {Item}
- *
- * @function
- * @private
- */
-export const splitItem = (transaction, leftItem, diff) => {
-  // create rightItem
-  const { client, clock } = leftItem.id
-  const rightItem = new Item(
-    createID(client, clock + diff),
-    leftItem,
-    createID(client, clock + diff - 1),
-    leftItem.right,
-    leftItem.rightOrigin,
-    leftItem.parent,
-    leftItem.parentSub,
-    leftItem.content.splice(diff)
-  )
-  if (leftItem.deleted) {
-    rightItem.markDeleted()
-  }
-  if (leftItem.keep) {
-    rightItem.keep = true
-  }
-  if (leftItem.redone !== null) {
-    rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff)
-  }
-  if (transaction != null) {
-    // update left (do not set leftItem.rightOrigin as it will lead to problems when syncing)
-    leftItem.right = rightItem
-    // update right
-    if (rightItem.right !== null) {
-      rightItem.right.left = rightItem
-    }
-    // right is more specific.
-    transaction._mergeStructs.push(rightItem)
-    // update parent._map
-    if (rightItem.parentSub !== null && rightItem.right === null) {
-      /** @type {YType} */ (rightItem.parent)._map.set(rightItem.parentSub, rightItem)
-    }
-  } else {
-    rightItem.left = null
-    rightItem.right = null
-  }
-  leftItem.length = diff
-  return rightItem
-}
-
-/**
- * More generalized version of splitItem. Split leftStruct into two structs
- * @param {Transaction?} transaction
- * @param {AbstractStruct} leftStruct
- * @param {number} diff
- * @return {GC|Item}
- *
- * @function
- * @private
- */
-export const splitStruct = (transaction, leftStruct, diff) => {
-  if (leftStruct instanceof Item) {
-    return splitItem(transaction, leftStruct, diff)
-  } else {
-    const rightItem = leftStruct.splice(diff)
-    transaction?._mergeStructs.push(rightItem)
-    return rightItem
-  }
-}
-
-/**
- * @param {Array<StackItem>} stack
- * @param {ID} id
- */
-const isDeletedByUndoStack = (stack, id) => array.some(stack, /** @param {StackItem} s */ s => s.deletes.hasId(id))
-
-/**
- * Redoes the effect of this operation.
- *
- * @param {Transaction} transaction The Yjs instance.
- * @param {Item} item
- * @param {Set<Item>} redoitems
- * @param {IdSet} itemsToDelete
- * @param {boolean} ignoreRemoteMapChanges
- * @param {import('../utils/UndoManager.js').UndoManager} um
- *
- * @return {Item|null}
- *
- * @private
- */
-export const redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) => {
-  const doc = transaction.doc
-  const store = doc.store
-  const ownClientID = doc.clientID
-  const redone = item.redone
-  if (redone !== null) {
-    return getItemCleanStart(transaction, redone)
-  }
-  let parentItem = /** @type {YType} */ (item.parent)._item
-  /**
-   * @type {Item|null}
-   */
-  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)
-    }
-  }
-  /**
-   * @type {YType}
-   */
-  const parentType = /** @type {YType} */ (parentItem === null ? 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
-    // find next cloned_redo items
-    while (left !== null) {
-      /**
-       * @type {Item|null}
-       */
-      let leftTrace = left
-      // trace redone until parent matches
-      while (leftTrace !== null && /** @type {YType} */ (leftTrace.parent)._item !== parentItem) {
-        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone)
-      }
-      if (leftTrace !== null && /** @type {YType} */ (leftTrace.parent)._item === parentItem) {
-        left = leftTrace
-        break
-      }
-      left = left.left
-    }
-    while (right !== null) {
-      /**
-       * @type {Item|null}
-       */
-      let rightTrace = right
-      // trace redone until parent matches
-      while (rightTrace !== null && /** @type {YType} */ (rightTrace.parent)._item !== parentItem) {
-        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone)
-      }
-      if (rightTrace !== null && /** @type {YType} */ (rightTrace.parent)._item === parentItem) {
-        right = rightTrace
-        break
-      }
-      right = right.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 || itemsToDelete.hasId(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)
-  const nextId = createID(ownClientID, nextClock)
-  const redoneItem = new Item(
-    nextId,
-    left, left && left.lastId,
-    right, right && right.id,
-    parentType,
-    item.parentSub,
-    item.content.copy()
-  )
-  item.redone = nextId
-  keepItem(redoneItem, true)
-  redoneItem.integrate(transaction, 0)
-  return redoneItem
-}
-
 /**
  * Abstract class that represents any content.
  */
@@ -386,56 +161,6 @@ export class Item extends AbstractStruct {
     this.info |= binary.BIT3
   }
 
-  /**
-   * Return the creator clientID of the missing op or define missing items and return null.
-   *
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @return {null | number}
-   */
-  getMissing (transaction, store) {
-    if (this.origin && (this.origin.clock >= getState(store, this.origin.client) || store.skips.hasId(this.origin))) {
-      return this.origin.client
-    }
-    if (this.rightOrigin && (this.rightOrigin.clock >= getState(store, this.rightOrigin.client) || store.skips.hasId(this.rightOrigin))) {
-      return this.rightOrigin.client
-    }
-    if (this.parent && this.parent.constructor === ID && (this.parent.clock >= getState(store, this.parent.client) || store.skips.hasId(this.parent))) {
-      return this.parent.client
-    }
-    // We have all missing ids, now find the items
-    if (this.origin) {
-      this.left = getItemCleanEnd(transaction, store, this.origin)
-      this.origin = this.left.lastId
-    }
-    if (this.rightOrigin) {
-      this.right = getItemCleanStart(transaction, this.rightOrigin)
-      this.rightOrigin = this.right.id
-    }
-    if ((this.left && this.left.constructor === GC) || (this.right && this.right.constructor === GC)) {
-      this.parent = null
-    } else if (this.parent == null) {
-      // only set parent if this shouldn't be garbage collected
-      if (this.left && this.left.constructor === Item) {
-        this.parent = this.left.parent
-        this.parentSub = this.left.parentSub
-      } else if (this.right && this.right.constructor === Item) {
-        this.parent = this.right.parent
-        this.parentSub = this.right.parentSub
-      }
-    } else if (this.parent.constructor === ID) {
-      const parentItem = getItem(store, this.parent)
-      if (parentItem.constructor === GC) {
-        this.parent = null
-      } else {
-        this.parent = /** @type {ContentType} */ (parentItem.content).type
-      }
-    } else if (typeof this.parent === 'string') {
-      this.parent = transaction.doc.get(this.parent)
-    }
-    return null
-  }
-
   /**
    * @param {Transaction} transaction
    * @param {number} offset
@@ -497,9 +222,9 @@ export class Item extends AbstractStruct {
               // Since this is to the left of o, we can break here
               break
             } // else, o might be integrated before an item that this conflicts with. If so, we will find it in the next iterations
-          } else if (o.origin !== null && itemsBeforeOrigin.has(getItem(transaction.doc.store, o.origin))) { // use getItem instead of getItemCleanEnd because we don't want / need to split items.
+          } else if (o.origin !== null && itemsBeforeOrigin.has(transaction.doc.store.getItem(o.origin))) { // use getItem instead of getItemCleanEnd because we don't want / need to split items.
             // case 2
-            if (!conflictingItems.has(getItem(transaction.doc.store, o.origin))) {
+            if (!conflictingItems.has(transaction.doc.store.getItem(o.origin))) {
               left = o
               conflictingItems.clear()
             }
@@ -534,7 +259,7 @@ export class Item extends AbstractStruct {
         // set as current parent value if right === null and this is parentSub
         /** @type {YType} */ (this.parent)._map.set(this.parentSub, this)
         if (this.left !== null) {
-          // this is the current attribute value of parent. delete right
+          // this is the current attribute value of parent. delete the previous value
           this.left.delete(transaction)
         }
       }
@@ -543,7 +268,7 @@ export class Item extends AbstractStruct {
         /** @type {YType} */ (this.parent)._length += this.length
       }
       addStructToIdSet(transaction.insertSet, this)
-      addStruct(transaction.doc.store, this)
+      transaction.doc.store.add(this)
       this.content.integrate(transaction, this)
       // add parent to transaction.changed
       addChangedTypeToTransaction(transaction, /** @type {YType} */ (this.parent), this.parentSub)
@@ -646,7 +371,7 @@ export class Item extends AbstractStruct {
         parent._length -= this.length
       }
       this.markDeleted()
-      addToIdSet(transaction.deleteSet, this.id.client, this.id.clock, this.length)
+      transaction.deleteSet.add(this.id.client, this.id.clock, this.length)
       addChangedTypeToTransaction(transaction, parent, this.parentSub)
       this.content.delete(transaction)
     }
@@ -668,6 +393,55 @@ export class Item extends AbstractStruct {
     }
   }
 
+  /**
+   * Split this into two items
+   * @param {Transaction?} transaction
+   * @param {number} diff
+   * @return {Item}
+   */
+  split (transaction, diff) {
+    // create rightItem
+    const { client, clock } = this.id
+    const rightItem = new Item(
+      createID(client, clock + diff),
+      this,
+      createID(client, clock + diff - 1),
+      this.right,
+      this.rightOrigin,
+      this.parent,
+      this.parentSub,
+      this.content.splice(diff)
+    )
+    if (this.deleted) {
+      rightItem.markDeleted()
+    }
+    if (this.keep) {
+      rightItem.keep = true
+    }
+    if (this.redone !== null) {
+      rightItem.redone = createID(this.redone.client, this.redone.clock + diff)
+    }
+    if (transaction != null) {
+      // update left (do not set leftItem.rightOrigin as it will lead to problems when syncing)
+      this.right = rightItem
+      // update right
+      if (rightItem.right !== null) {
+        rightItem.right.left = rightItem
+      }
+      // right is more specific.
+      transaction._mergeStructs.push(rightItem)
+      // update parent._map
+      if (rightItem.parentSub !== null && rightItem.right === null) {
+        /** @type {YType} */ (rightItem.parent)._map.set(rightItem.parentSub, rightItem)
+      }
+    } else {
+      rightItem.left = null
+      rightItem.right = null
+    }
+    this.length = diff
+    return rightItem
+  }
+
   /**
    * Transform the properties of this type to binary and write it to an
    * BinaryEncoder.
@@ -694,7 +468,7 @@ export class Item extends AbstractStruct {
       encoder.writeRightID(rightOrigin)
     }
     if (origin === null && rightOrigin === null) {
-      const parent = /** @type {YType<any>} */ (this.parent)
+      const parent = /** @type {YType} */ (this.parent)
       if (parent._item !== undefined) {
         const parentItem = parent._item
         if (parentItem === null) {
@@ -722,32 +496,16 @@ export class Item extends AbstractStruct {
     }
     this.content.write(encoder, offset, offsetEnd)
   }
-}
 
-/**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
- * @param {number} info
- */
-export const readItemContent = (decoder, info) => contentRefs[info & binary.BITS5](decoder)
+  get ref () {
+    return this.content.getRef()
+  }
+}
 
 /**
- * A lookup map for reading Item content.
- *
- * @type {Array<function(UpdateDecoderV1 | UpdateDecoderV2):AbstractContent>}
+ * @type {true}
  */
-export const contentRefs = [
-  () => { error.unexpectedCase() }, // GC is not ItemContent
-  readContentDeleted, // 1
-  readContentJSON, // 2
-  readContentBinary, // 3
-  readContentString, // 4
-  readContentEmbed, // 5
-  readContentFormat, // 6
-  readContentType, // 7
-  readContentAny, // 8
-  readContentDoc, // 9
-  () => { error.unexpectedCase() } // 10 - Skip is not ItemContent
-]
+Item.prototype.isItem = true
 
 /**
  * Do not implement this class!
@@ -834,10 +592,926 @@ export class AbstractContent {
     throw error.methodUnimplemented()
   }
 
+  /**
+   * @return {1|2|3|4|5|6|7|8|9}
+   */
+  getRef () {
+    throw error.methodUnimplemented()
+  }
+}
+
+export class ContentAny {
+  /**
+   * @param {Array<any>} arr
+   */
+  constructor (arr) {
+    /**
+     * @type {Array<any>}
+     */
+    this.arr = arr
+    isDevMode && object.deepFreeze(arr)
+  }
+
   /**
    * @return {number}
    */
+  getLength () {
+    return this.arr.length
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return this.arr
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentAny}
+   */
+  copy () {
+    return new ContentAny(this.arr)
+  }
+
+  /**
+   * @param {number} offset
+   * @return {ContentAny}
+   */
+  splice (offset) {
+    const right = new ContentAny(this.arr.slice(offset))
+    this.arr = this.arr.slice(0, offset)
+    return right
+  }
+
+  /**
+   * @param {ContentAny} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.arr = this.arr.concat(right.arr)
+    return true
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {Item} _item
+   */
+  integrate (_transaction, _item) {}
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    const end = this.arr.length - offsetEnd
+    encoder.writeLen(end - offset)
+    for (let i = offset; i < end; i++) {
+      const c = this.arr[i]
+      encoder.writeAny(c)
+    }
+  }
+
+  /**
+   * @return {8}
+   */
   getRef () {
+    return 8
+  }
+}
+
+export class ContentBinary {
+  /**
+   * @param {Uint8Array} content
+   */
+  constructor (content) {
+    this.content = content
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.content]
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentBinary}
+   */
+  copy () {
+    return new ContentBinary(this.content)
+  }
+
+  /**
+   * @param {number} _offset
+   * @return {ContentBinary}
+   */
+  splice (_offset) {
     throw error.methodUnimplemented()
   }
+
+  /**
+   * @param {ContentBinary} _right
+   * @return {boolean}
+   */
+  mergeWith (_right) {
+    return false
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {Item} _item
+   */
+  integrate (_transaction, _item) {}
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} _offset
+   * @param {number} _offsetEnd
+   */
+  write (encoder, _offset, _offsetEnd) {
+    encoder.writeBuf(this.content)
+  }
+
+  /**
+   * @return {3}
+   */
+  getRef () {
+    return 3
+  }
+}
+
+export class ContentDeleted {
+  /**
+   * @param {number} len
+   */
+  constructor (len) {
+    this.len = len
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return this.len
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return []
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return false
+  }
+
+  /**
+   * @return {ContentDeleted}
+   */
+  copy () {
+    return new ContentDeleted(this.len)
+  }
+
+  /**
+   * @param {number} offset
+   * @return {ContentDeleted}
+   */
+  splice (offset) {
+    const right = new ContentDeleted(this.len - offset)
+    this.len = offset
+    return right
+  }
+
+  /**
+   * @param {ContentDeleted} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.len += right.len
+    return true
+  }
+
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {
+    transaction.deleteSet.add(item.id.client, item.id.clock, this.len)
+    item.markDeleted()
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    encoder.writeLen(this.len - offset - offsetEnd)
+  }
+
+  /**
+   * @return {1}
+   */
+  getRef () {
+    return 1
+  }
+}
+
+/**
+ * @private
+ */
+export class ContentDoc {
+  /**
+   * @param {string} guid
+   * @param {Object<string,any>} opts
+   */
+  constructor (guid, opts) {
+    /**
+     * @type {Doc?}
+     */
+    this.doc = null
+    this.guid = guid
+    this.opts = opts
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.doc]
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentDoc}
+   */
+  copy () {
+    return new ContentDoc(this.guid, this.opts)
+  }
+
+  /**
+   * @param {number} _offset
+   * @return {ContentDoc}
+   */
+  splice (_offset) {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * @param {ContentDoc} _right
+   * @return {boolean}
+   */
+  mergeWith (_right) {
+    return false
+  }
+
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {
+    const opts = this.opts
+    if (this.doc == null) {
+      // we get the constructor from the existing doc to avoid import the doc module, leading to a
+      // circular dependency
+      this.doc = /** @type {Doc} */ (new /** @type {any} */ (transaction.doc.constructor)({ guid: this.guid, ...this.opts, shouldLoad: opts.shouldLoad || opts.autoLoad || false }))
+    }
+    this.doc._item = item
+    transaction.subdocsAdded.add(this.doc)
+    if (this.doc.shouldLoad) {
+      transaction.subdocsLoaded.add(this.doc)
+    }
+  }
+
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {
+    if (this.doc) {
+      if (transaction.subdocsAdded.has(this.doc)) {
+        transaction.subdocsAdded.delete(this.doc)
+      } else {
+        transaction.subdocsRemoved.add(this.doc)
+      }
+    }
+  }
+
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} _offset
+   * @param {number} _offsetEnd
+   */
+  write (encoder, _offset, _offsetEnd) {
+    encoder.writeString(this.guid)
+    encoder.writeAny(this.opts)
+  }
+
+  /**
+   * @return {9}
+   */
+  getRef () {
+    return 9
+  }
+}
+
+/**
+ * @param {Doc} ydoc
+ */
+export const createContentDocFromDoc = ydoc => {
+  /**
+   * @type {any}
+   */
+  const opts = {}
+  if (!ydoc.gc) {
+    opts.gc = false
+  }
+  if (ydoc.autoLoad) {
+    opts.autoLoad = true
+  }
+  if (ydoc.meta !== null) {
+    opts.meta = ydoc.meta
+  }
+  const c = new ContentDoc(ydoc.guid, opts)
+  c.doc = ydoc
+  return c
+}
+
+/**
+ * @private
+ */
+export class ContentEmbed {
+  /**
+   * @param {Object} embed
+   */
+  constructor (embed) {
+    this.embed = embed
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.embed]
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentEmbed}
+   */
+  copy () {
+    return new ContentEmbed(this.embed)
+  }
+
+  /**
+   * @param {number} _offset
+   * @return {ContentEmbed}
+   */
+  splice (_offset) {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * @param {ContentEmbed} _right
+   * @return {boolean}
+   */
+  mergeWith (_right) {
+    return false
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {Item} _item
+   */
+  integrate (_transaction, _item) {}
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} _offset
+   * @param {number} _offsetEnd
+   */
+  write (encoder, _offset, _offsetEnd) {
+    encoder.writeJSON(this.embed)
+  }
+
+  /**
+   * @return {5}
+   */
+  getRef () {
+    return 5
+  }
+}
+
+/**
+ * @private
+ */
+export class ContentFormat {
+  /**
+   * @param {string} key
+   * @param {Object} value
+   */
+  constructor (key, value) {
+    this.key = key
+    this.value = value
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return []
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return false
+  }
+
+  /**
+   * @return {ContentFormat}
+   */
+  copy () {
+    return new ContentFormat(this.key, this.value)
+  }
+
+  /**
+   * @param {number} _offset
+   * @return {ContentFormat}
+   */
+  splice (_offset) {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * @param {ContentFormat} _right
+   * @return {boolean}
+   */
+  mergeWith (_right) {
+    return false
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {Item} item
+   */
+  integrate (_transaction, item) {
+    // @todo searchmarker are currently unsupported for rich text documents
+    const p = /** @type {import('../ytype.js').YType<any>} */ (item.parent)
+    p._searchMarker = null
+    p._hasFormatting = true
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} _offset
+   * @param {number} _offsetEnd
+   */
+  write (encoder, _offset, _offsetEnd) {
+    encoder.writeKey(this.key)
+    encoder.writeJSON(this.value)
+  }
+
+  /**
+   * @return {6}
+   */
+  getRef () {
+    return 6
+  }
+}
+
+/**
+ * @private
+ */
+export class ContentJSON {
+  /**
+   * @param {Array<any>} arr
+   */
+  constructor (arr) {
+    /**
+     * @type {Array<any>}
+     */
+    this.arr = arr
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return this.arr.length
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return this.arr
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentJSON}
+   */
+  copy () {
+    return new ContentJSON(this.arr)
+  }
+
+  /**
+   * @param {number} offset
+   * @return {ContentJSON}
+   */
+  splice (offset) {
+    const right = new ContentJSON(this.arr.slice(offset))
+    this.arr = this.arr.slice(0, offset)
+    return right
+  }
+
+  /**
+   * @param {ContentJSON} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.arr = this.arr.concat(right.arr)
+    return true
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {Item} _item
+   */
+  integrate (_transaction, _item) {}
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    const end = this.arr.length - offsetEnd
+    encoder.writeLen(end - offset)
+    for (let i = offset; i < end; i++) {
+      const c = this.arr[i]
+      encoder.writeString(c === undefined ? 'undefined' : JSON.stringify(c))
+    }
+  }
+
+  /**
+   * @return {2}
+   */
+  getRef () {
+    return 2
+  }
+}
+
+/**
+ * @private
+ */
+export class ContentString {
+  /**
+   * @param {string} str
+   */
+  constructor (str) {
+    /**
+     * @type {string}
+     */
+    this.str = str
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return this.str.length
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return this.str.split('')
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentString}
+   */
+  copy () {
+    return new ContentString(this.str)
+  }
+
+  /**
+   * @param {number} offset
+   * @return {ContentString}
+   */
+  splice (offset) {
+    const right = new ContentString(this.str.slice(offset))
+    this.str = this.str.slice(0, offset)
+
+    // Prevent encoding invalid documents because of splitting of surrogate pairs: https://github.com/yjs/yjs/issues/248
+    const firstCharCode = this.str.charCodeAt(offset - 1)
+    if (firstCharCode >= 0xD800 && firstCharCode <= 0xDBFF) {
+      // Last character of the left split is the start of a surrogate utf16/ucs2 pair.
+      // We don't support splitting of surrogate pairs because this may lead to invalid documents.
+      // Replace the invalid character with a unicode replacement character (� / U+FFFD)
+      this.str = this.str.slice(0, offset - 1) + '�'
+      // replace right as well
+      right.str = '�' + right.str.slice(1)
+    }
+    return right
+  }
+
+  /**
+   * @param {ContentString} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.str += right.str
+    return true
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {Item} _item
+   */
+  integrate (_transaction, _item) {}
+  /**
+   * @param {Transaction} _transaction
+   */
+  delete (_transaction) {}
+  /**
+   * @param {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    encoder.writeString((offset === 0 && offsetEnd === 0) ? this.str : this.str.slice(offset, this.str.length - offsetEnd))
+  }
+
+  /**
+   * @return {4}
+   */
+  getRef () {
+    return 4
+  }
+}
+
+export const YArrayRefID = 0
+export const YMapRefID = 1
+export const YTextRefID = 2
+export const YXmlElementRefID = 3
+export const YXmlFragmentRefID = 4
+export const YXmlHookRefID = 5
+export const YXmlTextRefID = 6
+
+/**
+ * @private
+ */
+export class ContentType {
+  /**
+   * @param {import('../ytype.js').YType} type
+   */
+  constructor (type) {
+    /**
+     * @type {import('../ytype.js').YType}
+     */
+    this.type = type
+  }
+
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.type]
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+
+  /**
+   * @return {ContentType}
+   */
+  copy () {
+    return new ContentType(this.type._copy())
+  }
+
+  /**
+   * @param {number} _offset
+   * @return {ContentType}
+   */
+  splice (_offset) {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * @param {ContentType} _right
+   * @return {boolean}
+   */
+  mergeWith (_right) {
+    return false
+  }
+
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {
+    this.type._integrate(transaction.doc, item)
+  }
+
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {
+    let item = this.type._start
+    while (item !== null) {
+      if (!item.deleted) {
+        item.delete(transaction)
+      } else if (!transaction.insertSet.hasId(item.id)) {
+        // 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
+        transaction._mergeStructs.push(item)
+      }
+      item = item.right
+    }
+    this.type._map.forEach(item => {
+      if (!item.deleted) {
+        item.delete(transaction)
+      } else if (!transaction.insertSet.hasId(item.id)) {
+        // same as above
+        transaction._mergeStructs.push(item)
+      }
+    })
+  }
+
+  /**
+   * @param {Transaction} tr
+   */
+  gc (tr) {
+    let item = this.type._start
+    while (item !== null) {
+      item.gc(tr, true)
+      item = item.right
+    }
+    this.type._start = null
+    this.type._map.forEach(/** @param {Item | null} item */ (item) => {
+      while (item !== null) {
+        item.gc(tr, true)
+        item = item.left
+      }
+    })
+    this.type._map = new Map()
+  }
+
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} _offset
+   * @param {number} _offsetEnd
+   */
+  write (encoder, _offset, _offsetEnd) {
+    this.type._write(encoder)
+  }
+
+  /**
+   * @return {7}
+   */
+  getRef () {
+    return 7
+  }
 }