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

package/src/utils/transaction-helpers.js

@@ -0,0 +1,413 @@
+import * as math from 'lib0/math'
+import * as error from 'lib0/error'
+import * as map from 'lib0/map'
+import * as set from 'lib0/set'
+
+import { createID } from './ID.js'
+
+/**
+ * These modules don't require any imports.
+ * These helpers are used by items to integrate themselves
+ */
+
+/**
+ * Perform a binary search on a sorted array
+ * @param {Array<Item|GC|Skip>} structs
+ * @param {number} clock
+ * @return {number}
+ *
+ * @private
+ * @function
+ */
+export const findIndexSS = (structs, clock) => {
+  let left = 0
+  let right = structs.length - 1
+  let mid = structs[right]
+  let midclock = mid.id.clock
+  if (midclock === clock) {
+    return right
+  }
+  // @todo does it even make sense to pivot the search?
+  // If a good split misses, it might actually increase the time to find the correct item.
+  // Currently, the only advantage is that search with pivoting might find the item on the first try.
+  let midindex = math.floor((clock / (midclock + mid.length - 1)) * right) // pivoting the search
+  while (left <= right) {
+    mid = structs[midindex]
+    midclock = mid.id.clock
+    if (midclock <= clock) {
+      if (clock < midclock + mid.length) {
+        return midindex
+      }
+      left = midindex + 1
+    } else {
+      right = midindex - 1
+    }
+    midindex = math.floor((left + right) / 2)
+  }
+  // Always check state before looking for a struct in StructStore
+  // Therefore the case of not finding a struct is unexpected
+  throw error.unexpectedCase()
+}
+
+/**
+ * @param {Transaction?} transaction
+ * @param {Array<Item|GC|Skip>} structs
+ * @param {number} clock
+ */
+export const findIndexCleanStart = (transaction, structs, clock) => {
+  const index = findIndexSS(structs, clock)
+  const struct = structs[index]
+  if (struct.id.clock < clock) {
+    structs.splice(index + 1, 0, splitStruct(transaction, struct, clock - struct.id.clock))
+    return index + 1
+  }
+  return index
+}
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {Transaction} transaction
+ * @param {ID} id
+ * @return {Item}
+ *
+ * @private
+ * @function
+ */
+export const getItemCleanStart = (transaction, id) => {
+  const structs = /** @type {Array<Item>} */ (transaction.doc.store.clients.get(id.client))
+  return structs[findIndexCleanStart(transaction, structs, id.clock)]
+}
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {Item}
+ *
+ * @private
+ * @function
+ */
+export const getItemCleanEnd = (transaction, store, id) => {
+  const structs = store.clients.get(id.client) || []
+  const index = findIndexSS(structs, id.clock)
+  const struct = structs[index]
+  if (id.clock !== struct.id.clock + struct.length - 1 && struct.isItem) {
+    structs.splice(index + 1, 0, /** @type {Item} */ (struct).split(transaction, id.clock - struct.id.clock + 1))
+  }
+  return /** @type {Item} */ (struct)
+}
+
+/**
+ * Replace `item` with `newitem` in store
+ * @param {Transaction} tr
+ * @param {GC|Item} struct
+ * @param {GC|Item} newStruct
+ *
+ * @private
+ * @function
+ */
+export const replaceStruct = (tr, struct, newStruct) => {
+  const structs = /** @type {Array<GC|Item>} */ (tr.doc.store.clients.get(struct.id.client))
+  structs[findIndexSS(structs, struct.id.clock)] = newStruct
+  tr._mergeStructs.push(newStruct)
+}
+
+/**
+ * Iterate over a range of structs
+ *
+ * @param {Transaction} transaction
+ * @param {Array<Item|GC>} structs
+ * @param {number} clockStart Inclusive start
+ * @param {number} len
+ * @param {function(GC|Item):void} f
+ *
+ * @function
+ */
+export const iterateStructs = (transaction, structs, clockStart, len, f) => {
+  if (len === 0) {
+    return
+  }
+  const clockEnd = clockStart + len
+  let index = findIndexCleanStart(transaction, structs, clockStart)
+  let struct
+  do {
+    struct = structs[index++]
+    if (clockEnd < struct.id.clock + struct.length) {
+      findIndexCleanStart(transaction, structs, clockEnd)
+    }
+    f(struct)
+  } while (index < structs.length && structs[index].id.clock < clockEnd)
+}
+
+/**
+ * Iterate over a range of structs without splitting the structs. You will get content that you did
+ * not expect.
+ *
+ * @param {Array<Item|GC>} structs
+ * @param {number} clockStart Inclusive start
+ * @param {number} len
+ * @param {(struct: GC|Item|Skip, offset:number, len:number)=>void} f
+ *
+ * @function
+ */
+export const iterateStructsWithoutSplits = (structs, clockStart, len, f) => {
+  if (len === 0) {
+    return
+  }
+  const clockEnd = clockStart + len
+  for (
+    let index = findIndexSS(structs, clockStart), struct = structs[index], clock = struct.id.clock;
+    clock < clockEnd;
+    struct = structs[++index], clock = struct.id.clock
+  ) {
+    const offset = clock < clockStart ? clockStart - clock : 0
+    f(struct, offset, math.min(clock + struct.length, clockEnd) - clock)
+    if (index + 1 === structs.length) break
+  }
+}
+
+/**
+ * More generalized version of splitItem. Split leftStruct into two structs
+ * @param {Transaction?} transaction
+ * @param {Item|GC|Skip} leftStruct
+ * @param {number} diff
+ * @return {GC|Item|Skip}
+ *
+ * @function
+ * @private
+ */
+export const splitStruct = (transaction, leftStruct, diff) => {
+  if (leftStruct.isItem) {
+    return /** @type {Item} */ (leftStruct).split(transaction, diff)
+  } else {
+    const rightItem = leftStruct.splice(diff)
+    transaction?._mergeStructs.push(rightItem)
+    return rightItem
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ *
+ * @private
+ * @function
+ */
+export const nextID = transaction => {
+  const y = transaction.doc
+  return createID(y.clientID, y.store.getClock(y.clientID))
+}
+
+/**
+ * If `type.parent` was added in current transaction, `type` technically
+ * did not change, it was just added and we should not fire events for `type`.
+ *
+ * @param {Transaction} transaction
+ * @param {YType} type
+ * @param {string|null} parentSub
+ */
+export const addChangedTypeToTransaction = (transaction, type, parentSub) => {
+  const item = type._item
+  if (item === null || !transaction.insertSet.hasId(item.id)) {
+    map.setIfUndefined(transaction.changed, type, set.create).add(parentSub)
+  }
+}
+
+/**
+ * @param {Array<GC | Item | Skip>} structs
+ * @param {number} pos
+ * @return {number} # of merged structs
+ */
+export const tryToMergeWithLefts = (structs, pos) => {
+  let right = structs[pos]
+  let left = structs[pos - 1]
+  let i = pos
+  for (; i > 0; right = left, left = structs[--i - 1]) {
+    if (left.deleted === right.deleted && left.constructor === right.constructor) {
+      if (left.mergeWith(/** @type {any} */ (right))) {
+        if (right.isItem && /** @type {Item} */ (right).parentSub !== null && /** @type {YType} */ (/** @type {Item} */ (right).parent)._map.get(/** @type {Item} */ (right).parentSub) === right) {
+          /** @type {YType} */ (right.parent)._map.set(right.parentSub, /** @type {Item} */ (left))
+        }
+        continue
+      }
+    }
+    break
+  }
+  const merged = pos - i
+  if (merged) {
+    // remove all merged structs from the array
+    structs.splice(pos + 1 - merged, merged)
+  }
+  return merged
+}
+
+/**
+ * @param {Transaction} tr
+ * @param {IdSet} ds
+ * @param {function(Item):boolean} gcFilter
+ */
+export const tryGcDeleteSet = (tr, ds, gcFilter) => {
+  for (const [client, _deleteItems] of ds.clients.entries()) {
+    const deleteItems = _deleteItems.getIds()
+    const structs = /** @type {Array<Item>} */ (tr.doc.store.clients.get(client))
+    for (let di = deleteItems.length - 1; di >= 0; di--) {
+      const deleteItem = deleteItems[di]
+      const endDeleteItemClock = deleteItem.clock + deleteItem.len
+      for (
+        let si = findIndexSS(structs, deleteItem.clock), struct = structs[si];
+        si < structs.length && struct.id.clock < endDeleteItemClock;
+        struct = structs[++si]
+      ) {
+        const struct = structs[si]
+        if (deleteItem.clock + deleteItem.len <= struct.id.clock) {
+          break
+        }
+        if (struct.isItem && struct.deleted && !(struct).keep && gcFilter(/** @type {Item} */ (struct))) {
+          /** @type {Item} */ (struct).gc(tr, false)
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @param {IdSet} ds
+ * @param {StructStore} store
+ */
+export const tryMerge = (ds, store) => {
+  // try to merge deleted / gc'd items
+  // merge from right to left for better efficiency and so we don't miss any merge targets
+  ds.clients.forEach((_deleteItems, client) => {
+    const deleteItems = _deleteItems.getIds()
+    const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client))
+    for (let di = deleteItems.length - 1; di >= 0; di--) {
+      const deleteItem = deleteItems[di]
+      // start with merging the item next to the last deleted item
+      const mostRightIndexToCheck = math.min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1))
+      for (
+        let si = mostRightIndexToCheck, struct = structs[si];
+        si > 0 && struct.id.clock >= deleteItem.clock;
+        struct = structs[si]
+      ) {
+        si -= 1 + tryToMergeWithLefts(structs, si)
+      }
+    }
+  })
+}
+
+/**
+ * @param {Transaction} tr
+ * @param {IdSet} idset
+ * @param {function(Item):boolean} gcFilter
+ */
+export const tryGc = (tr, idset, gcFilter) => {
+  tryGcDeleteSet(tr, idset, gcFilter)
+  tryMerge(idset, tr.doc.store)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {Item | null} item
+ */
+export const cleanupContextlessFormattingGap = (transaction, item) => {
+  if (!transaction.doc.cleanupFormatting) return 0
+  // iterate until item.right is null or content
+  while (item && item.right && (item.right.deleted || !item.right.countable)) {
+    item = item.right
+  }
+  const attrs = new Set()
+  // iterate back until a content item is found
+  while (item && (item.deleted || !item.countable)) {
+    if (!item.deleted && item.content.getRef() === 6) { // is a ContentFormat
+      const key = /** @type {ContentFormat} */ (item.content).key
+      if (attrs.has(key)) {
+        item.delete(transaction)
+        transaction.cleanUps.add(item.id.client, item.id.clock, item.length)
+      } else {
+        attrs.add(key)
+      }
+    }
+    item = item.left
+  }
+}
+
+/**
+ * @param {Map<string,any>} currentFormats
+ * @param {ContentFormat} format
+ *
+ * @private
+ * @function
+ */
+export const updateCurrentFormats = (currentFormats, { key, value }) => {
+  if (value === null) {
+    currentFormats.delete(key)
+  } else {
+    currentFormats.set(key, value)
+  }
+}
+
+/**
+ * Call this function after string content has been deleted in order to
+ * clean up formatting Items.
+ *
+ * @param {Transaction} transaction
+ * @param {Item} start
+ * @param {Item|null} curr exclusive end, automatically iterates to the next Content Item
+ * @param {Map<string,any>} startFormats
+ * @param {Map<string,any>} currFormats
+ * @return {number} The amount of formatting Items deleted.
+ *
+ * @function
+ */
+export const cleanupFormattingGap = (transaction, start, curr, startFormats, currFormats) => {
+  if (!transaction.doc.cleanupFormatting) return 0
+  /**
+   * @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.getRef() === 6) {
+      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
+      if (content.getRef() === 6) { // is ContentFormat
+        const { key, value } = /** @type {ContentFormat} */ (content)
+        const startFormatValue = startFormats.get(key) ?? null
+        if (endFormats.get(key) !== content || startFormatValue === value) {
+          // Either this format is overwritten or it is not necessary because the format already existed.
+          start.delete(transaction)
+          transaction.cleanUps.add(start.id.client, start.id.clock, start.length)
+          cleanups++
+          if (!reachedCurr && (currFormats.get(key) ?? null) === value && startFormatValue !== value) {
+            if (startFormatValue === null) {
+              currFormats.delete(key)
+            } else {
+              currFormats.set(key, startFormatValue)
+            }
+          }
+        }
+        if (!reachedCurr && !start.deleted) {
+          updateCurrentFormats(currFormats, /** @type {ContentFormat} */ (content))
+        }
+      }
+    }
+    start = /** @type {Item} */ (start.right)
+  }
+  return cleanups
+}

package/src/utils/updates.js

@@ -5,10 +5,16 @@ 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 { readIdSet, writeIdSet, createIdSet, intersectSets } from './ids.js'
+
+import { createID } from './ID.js'
+import { IdSetEncoderV1, IdSetEncoderV2, UpdateEncoderV1, UpdateEncoderV2 } from './UpdateEncoder.js'
+import { UpdateDecoderV1, UpdateDecoderV2 } from './UpdateDecoder.js'
+import { GC } from '../structs/GC.js'
 import {
+  Item,
   ContentAny,
   ContentBinary,
   ContentDeleted,
@@ -17,32 +23,12 @@ import {
   ContentFormat,
   ContentJSON,
   ContentString,
-  ContentType,
-  createID,
-  decodeStateVector,
-  IdSetEncoderV1,
-  IdSetEncoderV2,
-  GC,
-  Item,
-  mergeIdSets,
-  readIdSet,
-  readItemContent,
-  Skip,
-  UpdateDecoderV1,
-  UpdateDecoderV2,
-  UpdateEncoderV1,
-  UpdateEncoderV2,
-  writeIdSet,
-  createIdSet,
-  Doc,
-  applyUpdate,
-  applyUpdateV2,
-  readBlockSet,
-  writeBlockSet,
-  encodeStateAsUpdateV2
-} from '../internals.js'
-
-import * as idset from './IdSet.js'
+  ContentType
+} from '../structs/Item.js'
+import {
+  readItemContent
+} from '../ytype.js'
+import { Skip } from '../structs/Skip.js'
 
 /**
  * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
@@ -183,12 +169,6 @@ export class LazyStructWriter {
   }
 }
 
-/**
- * @param {Array<Uint8Array<ArrayBuffer>>} updates
- * @return {Uint8Array<ArrayBuffer>}
- */
-export const mergeUpdates = updates => mergeUpdatesV2(updates, UpdateDecoderV1, UpdateEncoderV1)
-
 /**
  * @param {Uint8Array} update
  * @param {typeof IdSetEncoderV1 | typeof IdSetEncoderV2} YEncoder
@@ -252,7 +232,7 @@ export const encodeStateVectorFromUpdate = update => encodeStateVectorFromUpdate
 /**
  * @param {Uint8Array} update
  * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]
- * @return {import('./meta.js').ContentIds}
+ * @return {ContentIds}
  */
 export const createContentIdsFromUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
   const updateDecoder = new YDecoder(decoding.createDecoder(update))
@@ -284,7 +264,7 @@ export const createContentIdsFromUpdateV2 = (update, YDecoder = UpdateDecoderV2)
 
 /**
  * @param {Uint8Array} update
- * @return {import('./meta.js').ContentIds}
+ * @return {ContentIds}
  */
 export const createContentIdsFromUpdate = update => createContentIdsFromUpdateV2(update, UpdateDecoderV1)
 
@@ -294,7 +274,7 @@ export const createContentIdsFromUpdate = update => createContentIdsFromUpdateV2
  *
  * @param {Item | GC | Skip} left
  * @param {number} diff
- * @return {Item | GC}
+ * @return {Item | GC | Skip}
  */
 export const sliceStruct = (left, diff) => {
   if (left.constructor === GC) {
@@ -319,88 +299,6 @@ export const sliceStruct = (left, diff) => {
   }
 }
 
-/**
- *
- * This function works similarly to `readUpdateV2`.
- *
- * @param {Array<Uint8Array<ArrayBuffer>>} updates
- * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]
- * @param {typeof UpdateEncoderV1 | typeof UpdateEncoderV2} [YEncoder]
- * @return {Uint8Array<ArrayBuffer>}
- */
-export const mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
-  if (updates.length === 1) {
-    return updates[0]
-  } else if (updates.length === 0) {
-    return encodeStateAsUpdateV2(new Doc(), new Uint8Array([0]), new YEncoder())
-  }
-  const updateDecoders = updates.map(update => new YDecoder(decoding.createDecoder(update)))
-  const blocksets = updateDecoders.map(dec => readBlockSet(dec))
-
-  const mergedBlockset = blocksets[0]
-  for (let i = 1; i < blocksets.length; i++) {
-    mergedBlockset.insertInto(blocksets[i])
-  }
-  const updateEncoder = new YEncoder()
-  writeBlockSet(updateEncoder, mergedBlockset)
-  const dss = updateDecoders.map(decoder => readIdSet(decoder))
-  const ds = mergeIdSets(dss)
-  writeIdSet(updateEncoder, ds)
-  return updateEncoder.toUint8Array()
-}
-
-/**
- * @deprecated
- * @param {Uint8Array} update
- * @param {Uint8Array} sv
- * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]
- * @param {typeof UpdateEncoderV1 | typeof UpdateEncoderV2} [YEncoder]
- */
-export const diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
-  const state = decodeStateVector(sv)
-  const encoder = new YEncoder()
-  const lazyStructWriter = new LazyStructWriter(encoder)
-  const decoder = new YDecoder(decoding.createDecoder(update))
-  const reader = new LazyStructReader(decoder, false)
-  while (reader.curr) {
-    const curr = reader.curr
-    const currClient = curr.id.client
-    const svClock = state.get(currClient) || 0
-    if (reader.curr.constructor === Skip) {
-      // the first written struct shouldn't be a skip
-      reader.next()
-      continue
-    }
-    if (curr.id.clock + curr.length > svClock) {
-      writeStructToLazyStructWriter(lazyStructWriter, curr, math.max(svClock - curr.id.clock, 0), 0)
-      reader.next()
-      while (reader.curr && reader.curr.id.client === currClient) {
-        writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0, 0)
-        reader.next()
-      }
-    } else {
-      // read until something new comes up
-      while (reader.curr && reader.curr.id.client === currClient && reader.curr.id.clock + reader.curr.length <= svClock) {
-        reader.next()
-      }
-    }
-  }
-  finishLazyStructWriting(lazyStructWriter)
-  // write ds
-  const ds = readIdSet(decoder)
-  writeIdSet(encoder, ds)
-  return encoder.toUint8Array()
-}
-
-/**
- * @deprecated
- * @todo remove this in favor of intersectupdate
- *
- * @param {Uint8Array<ArrayBuffer>} update
- * @param {Uint8Array<ArrayBuffer>} sv
- */
-export const diffUpdate = (update, sv) => diffUpdateV2(update, sv, UpdateDecoderV1, UpdateEncoderV1)
-
 /**
  * @param {LazyStructWriter} lazyWriter
  */
@@ -414,11 +312,11 @@ const flushLazyStructWriter = lazyWriter => {
 
 /**
  * @param {LazyStructWriter} lazyWriter
- * @param {Item | GC} struct
+ * @param {Item | GC | Skip} struct
  * @param {number} offset
  * @param {number} offsetEnd
  */
-const writeStructToLazyStructWriter = (lazyWriter, struct, offset, offsetEnd) => {
+export const writeStructToLazyStructWriter = (lazyWriter, struct, offset, offsetEnd) => {
   // flush curr if we start another client
   if (lazyWriter.written > 0 && lazyWriter.currClient !== struct.id.client) {
     flushLazyStructWriter(lazyWriter)
@@ -440,7 +338,7 @@ const writeStructToLazyStructWriter = (lazyWriter, struct, offset, offsetEnd) =>
  *
  * @param {LazyStructWriter} lazyWriter
  */
-const finishLazyStructWriting = (lazyWriter) => {
+export const finishLazyStructWriting = (lazyWriter) => {
   flushLazyStructWriter(lazyWriter)
 
   // this is a fresh encoder because we called flushCurr
@@ -541,7 +439,7 @@ const createObfuscator = ({ formatting = true, subdocs = true, name = true } = {
             const c = /** @type {ContentDoc} */ (content)
             if (subdocs) {
               c.opts = {}
-              c.doc.guid = i + ''
+              c.guid = i + ''
             }
             break
           }
@@ -625,7 +523,7 @@ export const convertUpdateFormatV2ToV1 = update => convertUpdateFormat(update, f
  * overlapping portion is included in the result.
  *
  * @param {Uint8Array} update
- * @param {import('./meta.js').ContentIds} contentIds - Pattern specifying which content to include
+ * @param {ContentIds} contentIds - Pattern specifying which content to include
  * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]
  * @param {typeof UpdateEncoderV1 | typeof UpdateEncoderV2} [YEncoder]
  * @return {Uint8Array<ArrayBuffer>}
@@ -643,7 +541,7 @@ export const intersectUpdateWithContentIdsV2 = (update, contentIds, YDecoder = U
     let firstWrite = false
     while (reader.curr != null && reader.curr.id.client === currClientId) {
       const curr = reader.curr
-      for (const slice of inserts.slice(currClientId, nextClock, curr.length)) {
+      for (const slice of inserts.slice(currClientId, curr.id.clock, curr.length)) {
         if (slice.exists) {
           const skipLen = slice.clock - nextClock
           if (skipLen > 0 && firstWrite) {
@@ -662,7 +560,7 @@ export const intersectUpdateWithContentIdsV2 = (update, contentIds, YDecoder = U
   finishLazyStructWriting(lazyStructWriter)
   // Filter the delete set to only include entries in contentIds.deletes
   const ds = readIdSet(decoder)
-  const filteredDs = idset.intersectSets(ds, deletes)
+  const filteredDs = intersectSets(ds, deletes)
   writeIdSet(encoder, filteredDs)
   return encoder.toUint8Array()
 }
@@ -671,28 +569,8 @@ export const intersectUpdateWithContentIdsV2 = (update, contentIds, YDecoder = U
  * Filter an update (V1 format) to only include content specified by a ContentIds pattern.
  *
  * @param {Uint8Array} update
- * @param {import('./meta.js').ContentIds} contentIds - Pattern specifying which content to include
+ * @param {ContentIds} contentIds - Pattern specifying which content to include
  * @return {Uint8Array<ArrayBuffer>}
  */
 export const intersectUpdateWithContentIds = (update, contentIds) =>
   intersectUpdateWithContentIdsV2(update, contentIds, UpdateDecoderV1, UpdateEncoderV1)
-
-/**
- * @param {Uint8Array} update
- * @param {import('./Doc.js').DocOpts} opts
- */
-export const createDocFromUpdate = (update, opts = {}) => {
-  const ydoc = new Doc(opts)
-  applyUpdate(ydoc, update)
-  return ydoc
-}
-
-/**
- * @param {Uint8Array} update
- * @param {import('./Doc.js').DocOpts} opts
- */
-export const createDocFromUpdateV2 = (update, opts = {}) => {
-  const ydoc = new Doc(opts)
-  applyUpdateV2(ydoc, update)
-  return ydoc
-}