@liveblocks/core 0.18.3 → 0.18.5

package/{index.js → dist/index.js}

@@ -997,9 +997,13 @@ var LiveList = class extends AbstractCrdt {
     return this._items.length;
   }
   push(element) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     return this.insert(element, this.length);
   }
   insert(element, index) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     if (index < 0 || index > this._items.length) {
       throw new Error(
         `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
@@ -1024,6 +1028,8 @@ var LiveList = class extends AbstractCrdt {
     }
   }
   move(index, targetIndex) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
@@ -1077,6 +1083,8 @@ var LiveList = class extends AbstractCrdt {
     }
   }
   delete(index) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     if (index < 0 || index >= this._items.length) {
       throw new Error(
         `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
@@ -1109,6 +1117,8 @@ var LiveList = class extends AbstractCrdt {
     }
   }
   clear() {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     if (this._pool) {
       const ops = [];
       const reverseOps = [];
@@ -1142,6 +1152,8 @@ var LiveList = class extends AbstractCrdt {
     }
   }
   set(index, item) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     if (index < 0 || index >= this._items.length) {
       throw new Error(
         `Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
@@ -1446,6 +1458,8 @@ var LiveMap = class extends AbstractCrdt {
     return liveNodeToLson(value);
   }
   set(key, value) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     const oldValue = this._map.get(key);
     if (oldValue) {
       oldValue._detach();
@@ -1479,6 +1493,8 @@ var LiveMap = class extends AbstractCrdt {
     return this._map.has(key);
   }
   delete(key) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     const item = this._map.get(key);
     if (item === void 0) {
       return false;
@@ -1849,12 +1865,16 @@ var LiveObject = class extends AbstractCrdt {
     return fromEntries(this._map);
   }
   set(key, value) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     this.update({ [key]: value });
   }
   get(key) {
     return this._map.get(key);
   }
   delete(key) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     const keyAsString = key;
     const oldValue = this._map.get(keyAsString);
     if (oldValue === void 0) {
@@ -1903,6 +1923,8 @@ var LiveObject = class extends AbstractCrdt {
     );
   }
   update(patch) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     if (this._pool === void 0 || this._id === void 0) {
       for (const key in patch) {
         const newValue = patch[key];
@@ -2392,418 +2414,107 @@ function errorIf(condition, message) {
   }
 }
 
-// src/immutable.ts
-function lsonObjectToJson(obj) {
-  const result = {};
-  for (const key in obj) {
-    const val = obj[key];
-    if (val !== void 0) {
-      result[key] = lsonToJson(val);
-    }
+// src/EventSource.ts
+function makeEventSource() {
+  const _onetimeObservers = /* @__PURE__ */ new Set();
+  const _observers = /* @__PURE__ */ new Set();
+  function subscribe(callback) {
+    _observers.add(callback);
+    return () => _observers.delete(callback);
   }
-  return result;
-}
-function liveObjectToJson(liveObject) {
-  return lsonObjectToJson(liveObject.toObject());
-}
-function liveMapToJson(map) {
-  const result = {};
-  for (const [key, value] of map.entries()) {
-    result[key] = lsonToJson(value);
+  function subscribeOnce(callback) {
+    _onetimeObservers.add(callback);
+    return () => _onetimeObservers.delete(callback);
   }
-  return result;
-}
-function lsonListToJson(value) {
-  return value.map(lsonToJson);
-}
-function liveListToJson(value) {
-  return lsonListToJson(value.toArray());
-}
-function lsonToJson(value) {
-  if (value instanceof LiveObject) {
-    return liveObjectToJson(value);
-  } else if (value instanceof LiveList) {
-    return liveListToJson(value);
-  } else if (value instanceof LiveMap) {
-    return liveMapToJson(value);
-  } else if (value instanceof LiveRegister) {
-    return value.data;
+  function notify(event) {
+    _onetimeObservers.forEach((callback) => callback(event));
+    _onetimeObservers.clear();
+    _observers.forEach((callback) => callback(event));
   }
-  if (Array.isArray(value)) {
-    return lsonListToJson(value);
-  } else if (isPlainObject(value)) {
-    return lsonObjectToJson(value);
+  function clear() {
+    _onetimeObservers.clear();
+    _observers.clear();
   }
-  return value;
+  return {
+    notify,
+    subscribe,
+    subscribeOnce,
+    clear,
+    observable: {
+      subscribe,
+      subscribeOnce
+    }
+  };
 }
-function deepLiveify(value) {
-  if (Array.isArray(value)) {
-    return new LiveList(value.map(deepLiveify));
-  } else if (isPlainObject(value)) {
-    const init = {};
-    for (const key in value) {
-      const val = value[key];
+
+// src/ImmutableRef.ts
+function merge(target, patch) {
+  let updated = false;
+  const newValue = __spreadValues({}, target);
+  Object.keys(patch).forEach((k) => {
+    const key = k;
+    const val = patch[key];
+    if (newValue[key] !== val) {
       if (val === void 0) {
-        continue;
+        delete newValue[key];
+      } else {
+        newValue[key] = val;
       }
-      init[key] = deepLiveify(val);
+      updated = true;
     }
-    return new LiveObject(init);
-  } else {
-    return value;
-  }
+  });
+  return updated ? newValue : target;
 }
-function patchLiveList(liveList, prev, next) {
-  let i = 0;
-  let prevEnd = prev.length - 1;
-  let nextEnd = next.length - 1;
-  let prevNode = prev[0];
-  let nextNode = next[0];
-  outer: {
-    while (prevNode === nextNode) {
-      ++i;
-      if (i > prevEnd || i > nextEnd) {
-        break outer;
-      }
-      prevNode = prev[i];
-      nextNode = next[i];
-    }
-    prevNode = prev[prevEnd];
-    nextNode = next[nextEnd];
-    while (prevNode === nextNode) {
-      prevEnd--;
-      nextEnd--;
-      if (i > prevEnd || i > nextEnd) {
-        break outer;
-      }
-      prevNode = prev[prevEnd];
-      nextNode = next[nextEnd];
-    }
+var ImmutableRef = class {
+  constructor() {
+    this._ev = makeEventSource();
   }
-  if (i > prevEnd) {
-    if (i <= nextEnd) {
-      while (i <= nextEnd) {
-        liveList.insert(deepLiveify(next[i]), i);
-        i++;
-      }
-    }
-  } else if (i > nextEnd) {
-    let localI = i;
-    while (localI <= prevEnd) {
-      liveList.delete(i);
-      localI++;
-    }
-  } else {
-    while (i <= prevEnd && i <= nextEnd) {
-      prevNode = prev[i];
-      nextNode = next[i];
-      const liveListNode = liveList.get(i);
-      if (isLiveObject(liveListNode) && isPlainObject(prevNode) && isPlainObject(nextNode)) {
-        patchLiveObject(liveListNode, prevNode, nextNode);
-      } else {
-        liveList.set(i, deepLiveify(nextNode));
-      }
-      i++;
-    }
-    while (i <= nextEnd) {
-      liveList.insert(deepLiveify(next[i]), i);
-      i++;
-    }
-    let localI = i;
-    while (localI <= prevEnd) {
-      liveList.delete(i);
-      localI++;
-    }
+  get didInvalidate() {
+    return this._ev.observable;
   }
-}
-function patchLiveObjectKey(liveObject, key, prev, next) {
-  if (process.env.NODE_ENV !== "production") {
-    const nonSerializableValue = findNonSerializableValue(next);
-    if (nonSerializableValue) {
-      error(
-        `New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.
-Only serializable value can be synced with Liveblocks.`
-      );
-      return;
+  invalidate() {
+    if (this._cache !== void 0) {
+      this._cache = void 0;
+      this._ev.notify();
     }
   }
-  const value = liveObject.get(key);
-  if (next === void 0) {
-    liveObject.delete(key);
-  } else if (value === void 0) {
-    liveObject.set(key, deepLiveify(next));
-  } else if (prev === next) {
-    return;
-  } else if (isLiveList(value) && Array.isArray(prev) && Array.isArray(next)) {
-    patchLiveList(value, prev, next);
-  } else if (isLiveObject(value) && isPlainObject(prev) && isPlainObject(next)) {
-    patchLiveObject(value, prev, next);
-  } else {
-    liveObject.set(key, deepLiveify(next));
-  }
-}
-function patchLiveObject(root, prev, next) {
-  const updates = {};
-  for (const key in next) {
-    patchLiveObjectKey(root, key, prev[key], next[key]);
+  get current() {
+    var _a;
+    return (_a = this._cache) != null ? _a : this._cache = this._toImmutable();
   }
-  for (const key in prev) {
-    if (next[key] === void 0) {
-      root.delete(key);
-    }
+};
+
+// src/MeRef.ts
+var MeRef = class extends ImmutableRef {
+  constructor(initialPresence) {
+    super();
+    this._me = freeze(compactObject(initialPresence));
   }
-  if (Object.keys(updates).length > 0) {
-    root.update(updates);
+  _toImmutable() {
+    return this._me;
   }
-}
-function getParentsPath(node) {
-  const path = [];
-  while (node.parent.type === "HasParent") {
-    if (isLiveList(node.parent.node)) {
-      path.push(node.parent.node._indexOfPosition(node.parent.key));
-    } else {
-      path.push(node.parent.key);
+  patch(patch) {
+    const oldMe = this._me;
+    const newMe = merge(oldMe, patch);
+    if (oldMe !== newMe) {
+      this._me = freeze(newMe);
+      this.invalidate();
     }
-    node = node.parent.node;
   }
-  return path;
-}
-function legacy_patchImmutableObject(state, updates) {
-  return updates.reduce(
-    (state2, update) => legacy_patchImmutableObjectWithUpdate(state2, update),
-    state
-  );
+};
+
+// src/LegacyArray.ts
+function asArrayWithLegacyMethods(arr) {
+  Object.defineProperty(arr, "count", {
+    value: arr.length,
+    enumerable: false
+  });
+  Object.defineProperty(arr, "toArray", {
+    value: () => arr,
+    enumerable: false
+  });
+  return freeze(arr);
 }
-function legacy_patchImmutableObjectWithUpdate(state, update) {
-  const path = getParentsPath(update.node);
-  return legacy_patchImmutableNode(state, path, update);
-}
-function legacy_patchImmutableNode(state, path, update) {
-  var _a, _b, _c, _d;
-  const pathItem = path.pop();
-  if (pathItem === void 0) {
-    switch (update.type) {
-      case "LiveObject": {
-        if (state === null || typeof state !== "object" || Array.isArray(state)) {
-          throw new Error(
-            "Internal: received update on LiveObject but state was not an object"
-          );
-        }
-        const newState = Object.assign({}, state);
-        for (const key in update.updates) {
-          if (((_a = update.updates[key]) == null ? void 0 : _a.type) === "update") {
-            const val = update.node.get(key);
-            if (val !== void 0) {
-              newState[key] = lsonToJson(val);
-            }
-          } else if (((_b = update.updates[key]) == null ? void 0 : _b.type) === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-      case "LiveList": {
-        if (!Array.isArray(state)) {
-          throw new Error(
-            "Internal: received update on LiveList but state was not an array"
-          );
-        }
-        let newState = state.map((x) => x);
-        for (const listUpdate of update.updates) {
-          if (listUpdate.type === "set") {
-            newState = newState.map(
-              (item, index) => index === listUpdate.index ? lsonToJson(listUpdate.item) : item
-            );
-          } else if (listUpdate.type === "insert") {
-            if (listUpdate.index === newState.length) {
-              newState.push(lsonToJson(listUpdate.item));
-            } else {
-              newState = [
-                ...newState.slice(0, listUpdate.index),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index)
-              ];
-            }
-          } else if (listUpdate.type === "delete") {
-            newState.splice(listUpdate.index, 1);
-          } else if (listUpdate.type === "move") {
-            if (listUpdate.previousIndex > listUpdate.index) {
-              newState = [
-                ...newState.slice(0, listUpdate.index),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
-                ...newState.slice(listUpdate.previousIndex + 1)
-              ];
-            } else {
-              newState = [
-                ...newState.slice(0, listUpdate.previousIndex),
-                ...newState.slice(
-                  listUpdate.previousIndex + 1,
-                  listUpdate.index + 1
-                ),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index + 1)
-              ];
-            }
-          }
-        }
-        return newState;
-      }
-      case "LiveMap": {
-        if (state === null || typeof state !== "object" || Array.isArray(state)) {
-          throw new Error(
-            "Internal: received update on LiveMap but state was not an object"
-          );
-        }
-        const newState = Object.assign({}, state);
-        for (const key in update.updates) {
-          if (((_c = update.updates[key]) == null ? void 0 : _c.type) === "update") {
-            const value = update.node.get(key);
-            if (value !== void 0) {
-              newState[key] = lsonToJson(value);
-            }
-          } else if (((_d = update.updates[key]) == null ? void 0 : _d.type) === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-    }
-  }
-  if (Array.isArray(state)) {
-    const newArray = [...state];
-    newArray[pathItem] = legacy_patchImmutableNode(
-      state[pathItem],
-      path,
-      update
-    );
-    return newArray;
-  } else if (state !== null && typeof state === "object") {
-    const node = state[pathItem];
-    if (node === void 0) {
-      return state;
-    } else {
-      return __spreadProps(__spreadValues({}, state), {
-        [pathItem]: legacy_patchImmutableNode(node, path, update)
-      });
-    }
-  } else {
-    return state;
-  }
-}
-
-// src/LegacyArray.ts
-function asArrayWithLegacyMethods(arr) {
-  Object.defineProperty(arr, "count", {
-    value: arr.length,
-    enumerable: false
-  });
-  Object.defineProperty(arr, "toArray", {
-    value: () => arr,
-    enumerable: false
-  });
-  return freeze(arr);
-}
-
-// src/types/Json.ts
-function isJsonScalar(data) {
-  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
-}
-function isJsonArray(data) {
-  return Array.isArray(data);
-}
-function isJsonObject(data) {
-  return !isJsonScalar(data) && !isJsonArray(data);
-}
-
-// src/EventSource.ts
-function makeEventSource() {
-  const _onetimeObservers = /* @__PURE__ */ new Set();
-  const _observers = /* @__PURE__ */ new Set();
-  function subscribe(callback) {
-    _observers.add(callback);
-    return () => _observers.delete(callback);
-  }
-  function subscribeOnce(callback) {
-    _onetimeObservers.add(callback);
-    return () => _onetimeObservers.delete(callback);
-  }
-  function notify(event) {
-    _onetimeObservers.forEach((callback) => callback(event));
-    _onetimeObservers.clear();
-    _observers.forEach((callback) => callback(event));
-  }
-  function clear() {
-    _onetimeObservers.clear();
-    _observers.clear();
-  }
-  return {
-    notify,
-    subscribe,
-    subscribeOnce,
-    clear,
-    observable: {
-      subscribe,
-      subscribeOnce
-    }
-  };
-}
-
-// src/ImmutableRef.ts
-function merge(target, patch) {
-  let updated = false;
-  const newValue = __spreadValues({}, target);
-  Object.keys(patch).forEach((k) => {
-    const key = k;
-    const val = patch[key];
-    if (newValue[key] !== val) {
-      if (val === void 0) {
-        delete newValue[key];
-      } else {
-        newValue[key] = val;
-      }
-      updated = true;
-    }
-  });
-  return updated ? newValue : target;
-}
-var ImmutableRef = class {
-  constructor() {
-    this._ev = makeEventSource();
-  }
-  get didInvalidate() {
-    return this._ev.observable;
-  }
-  invalidate() {
-    if (this._cache !== void 0) {
-      this._cache = void 0;
-      this._ev.notify();
-    }
-  }
-  get current() {
-    var _a;
-    return (_a = this._cache) != null ? _a : this._cache = this._toImmutable();
-  }
-};
-
-// src/MeRef.ts
-var MeRef = class extends ImmutableRef {
-  constructor(initialPresence) {
-    super();
-    this._me = freeze(compactObject(initialPresence));
-  }
-  _toImmutable() {
-    return this._me;
-  }
-  patch(patch) {
-    const oldMe = this._me;
-    const newMe = merge(oldMe, patch);
-    if (oldMe !== newMe) {
-      this._me = freeze(newMe);
-      this.invalidate();
-    }
-  }
-};
 
 // src/OthersRef.ts
 function makeUser(conn, presence) {
@@ -2856,11 +2567,12 @@ var OthersRef = class extends ImmutableRef {
     }
     this.invalidate();
   }
-  setConnection(connectionId, metaUserId, metaUserInfo) {
+  setConnection(connectionId, metaUserId, metaUserInfo, metaIsReadonly) {
     this._connections[connectionId] = freeze({
       connectionId,
       id: metaUserId,
-      info: metaUserInfo
+      info: metaUserInfo,
+      isReadOnly: metaIsReadonly
     });
     if (this._presences[connectionId] !== void 0) {
       this._invalidateUser(connectionId);
@@ -2890,6 +2602,17 @@ var OthersRef = class extends ImmutableRef {
   }
 };
 
+// src/types/Json.ts
+function isJsonScalar(data) {
+  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+}
+function isJsonArray(data) {
+  return Array.isArray(data);
+}
+function isJsonObject(data) {
+  return !isJsonScalar(data) && !isJsonArray(data);
+}
+
 // src/ValueRef.ts
 var ValueRef = class extends ImmutableRef {
   constructor(initialValue) {
@@ -2966,6 +2689,13 @@ function makeStateMachine(state, config, mockedEffects) {
           notify({ storageUpdates }, doNotBatchUpdates);
         });
       }
+    },
+    assertStorageIsWritable: () => {
+      if (isConnectionSelfAware(state.connection.current) && state.connection.current.isReadOnly) {
+        throw new Error(
+          "Cannot write to storage with a read only user, please ensure the user has write permissions"
+        );
+      }
     }
   };
   const eventHub = {
@@ -3027,7 +2757,8 @@ function makeStateMachine(state, config, mockedEffects) {
       connectionId: conn.id,
       id: conn.userId,
       info: conn.userInfo,
-      presence: me
+      presence: me,
+      isReadOnly: conn.isReadOnly
     } : null
   );
   function createOrUpdateRootFromMessage(message, batchedUpdatesWrapper) {
@@ -3360,6 +3091,9 @@ function makeStateMachine(state, config, mockedEffects) {
       });
     }
   }
+  function isStorageReadOnly(scopes) {
+    return scopes.includes("room:read" /* Read */) && scopes.includes("room:presence:write" /* PresenceWrite */) && !scopes.includes("room:write" /* Write */);
+  }
   function authenticationSuccess(token, socket) {
     socket.addEventListener("message", onMessage);
     socket.addEventListener("open", onOpen);
@@ -3370,7 +3104,8 @@ function makeStateMachine(state, config, mockedEffects) {
         state: "connecting",
         id: token.actor,
         userInfo: token.info,
-        userId: token.id
+        userId: token.id,
+        isReadOnly: isStorageReadOnly(token.scopes)
       },
       batchUpdates
     );
@@ -3426,7 +3161,12 @@ function makeStateMachine(state, config, mockedEffects) {
     for (const key in message.users) {
       const user = message.users[key];
       const connectionId = Number(key);
-      state.others.setConnection(connectionId, user.id, user.info);
+      state.others.setConnection(
+        connectionId,
+        user.id,
+        user.info,
+        isStorageReadOnly(user.scopes)
+      );
     }
     return { type: "reset" };
   }
@@ -3442,7 +3182,12 @@ function makeStateMachine(state, config, mockedEffects) {
     });
   }
   function onUserJoinedMessage(message) {
-    state.others.setConnection(message.actor, message.id, message.info);
+    state.others.setConnection(
+      message.actor,
+      message.id,
+      message.info,
+      isStorageReadOnly(message.scopes)
+    );
     state.buffer.messages.push({
       type: 100 /* UPDATE_PRESENCE */,
       data: state.me.current,
@@ -3856,7 +3601,7 @@ function makeStateMachine(state, config, mockedEffects) {
     if (state.activeBatch) {
       return callback();
     }
-    let rv = void 0;
+    let returnValue = void 0;
     batchUpdates(() => {
       state.activeBatch = {
         ops: [],
@@ -3868,7 +3613,7 @@ function makeStateMachine(state, config, mockedEffects) {
         reverseOps: []
       };
       try {
-        rv = callback();
+        returnValue = callback();
       } finally {
         const currentBatch = state.activeBatch;
         state.activeBatch = null;
@@ -3885,7 +3630,7 @@ function makeStateMachine(state, config, mockedEffects) {
         tryFlushing();
       }
     });
-    return rv;
+    return returnValue;
   }
   function pauseHistory() {
     state.pausedHistory = [];
@@ -4048,7 +3793,7 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
   const ws = WebSocketPolyfill || WebSocket;
   return (token) => {
     return new ws(
-      `${liveblocksServer}/?token=${token}&version=${true ? "0.18.3" : "dev"}`
+      `${liveblocksServer}/?token=${token}&version=${true ? "0.18.5" : "dev"}`
     );
   };
 }
@@ -4266,6 +4011,306 @@ function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
   )}/public/authorize`;
 }
 
+// src/immutable.ts
+function lsonObjectToJson(obj) {
+  const result = {};
+  for (const key in obj) {
+    const val = obj[key];
+    if (val !== void 0) {
+      result[key] = lsonToJson(val);
+    }
+  }
+  return result;
+}
+function liveObjectToJson(liveObject) {
+  return lsonObjectToJson(liveObject.toObject());
+}
+function liveMapToJson(map) {
+  const result = {};
+  for (const [key, value] of map.entries()) {
+    result[key] = lsonToJson(value);
+  }
+  return result;
+}
+function lsonListToJson(value) {
+  return value.map(lsonToJson);
+}
+function liveListToJson(value) {
+  return lsonListToJson(value.toArray());
+}
+function lsonToJson(value) {
+  if (value instanceof LiveObject) {
+    return liveObjectToJson(value);
+  } else if (value instanceof LiveList) {
+    return liveListToJson(value);
+  } else if (value instanceof LiveMap) {
+    return liveMapToJson(value);
+  } else if (value instanceof LiveRegister) {
+    return value.data;
+  }
+  if (Array.isArray(value)) {
+    return lsonListToJson(value);
+  } else if (isPlainObject(value)) {
+    return lsonObjectToJson(value);
+  }
+  return value;
+}
+function deepLiveify(value) {
+  if (Array.isArray(value)) {
+    return new LiveList(value.map(deepLiveify));
+  } else if (isPlainObject(value)) {
+    const init = {};
+    for (const key in value) {
+      const val = value[key];
+      if (val === void 0) {
+        continue;
+      }
+      init[key] = deepLiveify(val);
+    }
+    return new LiveObject(init);
+  } else {
+    return value;
+  }
+}
+function patchLiveList(liveList, prev, next) {
+  let i = 0;
+  let prevEnd = prev.length - 1;
+  let nextEnd = next.length - 1;
+  let prevNode = prev[0];
+  let nextNode = next[0];
+  outer: {
+    while (prevNode === nextNode) {
+      ++i;
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
+      prevNode = prev[i];
+      nextNode = next[i];
+    }
+    prevNode = prev[prevEnd];
+    nextNode = next[nextEnd];
+    while (prevNode === nextNode) {
+      prevEnd--;
+      nextEnd--;
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
+      prevNode = prev[prevEnd];
+      nextNode = next[nextEnd];
+    }
+  }
+  if (i > prevEnd) {
+    if (i <= nextEnd) {
+      while (i <= nextEnd) {
+        liveList.insert(deepLiveify(next[i]), i);
+        i++;
+      }
+    }
+  } else if (i > nextEnd) {
+    let localI = i;
+    while (localI <= prevEnd) {
+      liveList.delete(i);
+      localI++;
+    }
+  } else {
+    while (i <= prevEnd && i <= nextEnd) {
+      prevNode = prev[i];
+      nextNode = next[i];
+      const liveListNode = liveList.get(i);
+      if (isLiveObject(liveListNode) && isPlainObject(prevNode) && isPlainObject(nextNode)) {
+        patchLiveObject(liveListNode, prevNode, nextNode);
+      } else {
+        liveList.set(i, deepLiveify(nextNode));
+      }
+      i++;
+    }
+    while (i <= nextEnd) {
+      liveList.insert(deepLiveify(next[i]), i);
+      i++;
+    }
+    let localI = i;
+    while (localI <= prevEnd) {
+      liveList.delete(i);
+      localI++;
+    }
+  }
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+  if (process.env.NODE_ENV !== "production") {
+    const nonSerializableValue = findNonSerializableValue(next);
+    if (nonSerializableValue) {
+      error(
+        `New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.
+Only serializable value can be synced with Liveblocks.`
+      );
+      return;
+    }
+  }
+  const value = liveObject.get(key);
+  if (next === void 0) {
+    liveObject.delete(key);
+  } else if (value === void 0) {
+    liveObject.set(key, deepLiveify(next));
+  } else if (prev === next) {
+    return;
+  } else if (isLiveList(value) && Array.isArray(prev) && Array.isArray(next)) {
+    patchLiveList(value, prev, next);
+  } else if (isLiveObject(value) && isPlainObject(prev) && isPlainObject(next)) {
+    patchLiveObject(value, prev, next);
+  } else {
+    liveObject.set(key, deepLiveify(next));
+  }
+}
+function patchLiveObject(root, prev, next) {
+  const updates = {};
+  for (const key in next) {
+    patchLiveObjectKey(root, key, prev[key], next[key]);
+  }
+  for (const key in prev) {
+    if (next[key] === void 0) {
+      root.delete(key);
+    }
+  }
+  if (Object.keys(updates).length > 0) {
+    root.update(updates);
+  }
+}
+function getParentsPath(node) {
+  const path = [];
+  while (node.parent.type === "HasParent") {
+    if (isLiveList(node.parent.node)) {
+      path.push(node.parent.node._indexOfPosition(node.parent.key));
+    } else {
+      path.push(node.parent.key);
+    }
+    node = node.parent.node;
+  }
+  return path;
+}
+function legacy_patchImmutableObject(state, updates) {
+  return updates.reduce(
+    (state2, update) => legacy_patchImmutableObjectWithUpdate(state2, update),
+    state
+  );
+}
+function legacy_patchImmutableObjectWithUpdate(state, update) {
+  const path = getParentsPath(update.node);
+  return legacy_patchImmutableNode(state, path, update);
+}
+function legacy_patchImmutableNode(state, path, update) {
+  var _a, _b, _c, _d;
+  const pathItem = path.pop();
+  if (pathItem === void 0) {
+    switch (update.type) {
+      case "LiveObject": {
+        if (state === null || typeof state !== "object" || Array.isArray(state)) {
+          throw new Error(
+            "Internal: received update on LiveObject but state was not an object"
+          );
+        }
+        const newState = Object.assign({}, state);
+        for (const key in update.updates) {
+          if (((_a = update.updates[key]) == null ? void 0 : _a.type) === "update") {
+            const val = update.node.get(key);
+            if (val !== void 0) {
+              newState[key] = lsonToJson(val);
+            }
+          } else if (((_b = update.updates[key]) == null ? void 0 : _b.type) === "delete") {
+            delete newState[key];
+          }
+        }
+        return newState;
+      }
+      case "LiveList": {
+        if (!Array.isArray(state)) {
+          throw new Error(
+            "Internal: received update on LiveList but state was not an array"
+          );
+        }
+        let newState = state.map((x) => x);
+        for (const listUpdate of update.updates) {
+          if (listUpdate.type === "set") {
+            newState = newState.map(
+              (item, index) => index === listUpdate.index ? lsonToJson(listUpdate.item) : item
+            );
+          } else if (listUpdate.type === "insert") {
+            if (listUpdate.index === newState.length) {
+              newState.push(lsonToJson(listUpdate.item));
+            } else {
+              newState = [
+                ...newState.slice(0, listUpdate.index),
+                lsonToJson(listUpdate.item),
+                ...newState.slice(listUpdate.index)
+              ];
+            }
+          } else if (listUpdate.type === "delete") {
+            newState.splice(listUpdate.index, 1);
+          } else if (listUpdate.type === "move") {
+            if (listUpdate.previousIndex > listUpdate.index) {
+              newState = [
+                ...newState.slice(0, listUpdate.index),
+                lsonToJson(listUpdate.item),
+                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
+                ...newState.slice(listUpdate.previousIndex + 1)
+              ];
+            } else {
+              newState = [
+                ...newState.slice(0, listUpdate.previousIndex),
+                ...newState.slice(
+                  listUpdate.previousIndex + 1,
+                  listUpdate.index + 1
+                ),
+                lsonToJson(listUpdate.item),
+                ...newState.slice(listUpdate.index + 1)
+              ];
+            }
+          }
+        }
+        return newState;
+      }
+      case "LiveMap": {
+        if (state === null || typeof state !== "object" || Array.isArray(state)) {
+          throw new Error(
+            "Internal: received update on LiveMap but state was not an object"
+          );
+        }
+        const newState = Object.assign({}, state);
+        for (const key in update.updates) {
+          if (((_c = update.updates[key]) == null ? void 0 : _c.type) === "update") {
+            const value = update.node.get(key);
+            if (value !== void 0) {
+              newState[key] = lsonToJson(value);
+            }
+          } else if (((_d = update.updates[key]) == null ? void 0 : _d.type) === "delete") {
+            delete newState[key];
+          }
+        }
+        return newState;
+      }
+    }
+  }
+  if (Array.isArray(state)) {
+    const newArray = [...state];
+    newArray[pathItem] = legacy_patchImmutableNode(
+      state[pathItem],
+      path,
+      update
+    );
+    return newArray;
+  } else if (state !== null && typeof state === "object") {
+    const node = state[pathItem];
+    if (node === void 0) {
+      return state;
+    } else {
+      return __spreadProps(__spreadValues({}, state), {
+        [pathItem]: legacy_patchImmutableNode(node, path, update)
+      });
+    }
+  } else {
+    return state;
+  }
+}
+
 // src/shallow.ts
 function shallowArray(xs, ys) {
   if (xs.length !== ys.length) {