@liveblocks/client 0.16.1 → 0.16.4-beta1

package/index.js

@@ -0,0 +1,1924 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var LiveObject = require('./shared.js');
+
+var BACKOFF_RETRY_DELAYS = [250, 500, 1000, 2000, 4000, 8000, 10000];
+var BACKOFF_RETRY_DELAYS_SLOW = [2000, 30000, 60000, 300000];
+var HEARTBEAT_INTERVAL = 30000;
+var PONG_TIMEOUT = 2000;
+
+function isValidRoomEventType(value) {
+  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection";
+}
+
+function makeIdFactory(connectionId) {
+  var count = 0;
+  return function () {
+    return connectionId + ":" + count++;
+  };
+}
+
+function makeOthers(userMap) {
+  var _ref;
+
+  var users = Object.values(userMap).map(function (user) {
+    user._hasReceivedInitialPresence;
+        var publicKeys = LiveObject._objectWithoutPropertiesLoose(user, ["_hasReceivedInitialPresence"]);
+
+    return publicKeys;
+  });
+  return _ref = {
+    get count() {
+      return users.length;
+    }
+
+  }, _ref[Symbol.iterator] = function () {
+    return users[Symbol.iterator]();
+  }, _ref.map = function map(callback) {
+    return users.map(callback);
+  }, _ref.toArray = function toArray() {
+    return users;
+  }, _ref;
+}
+
+function makeStateMachine(state, context, mockedEffects) {
+  var effects = mockedEffects || {
+    authenticate: function authenticate(auth, createWebSocket) {
+      var token = state.token;
+
+      if (token && LiveObject.isTokenValid(token)) {
+        var parsedToken = parseToken(token);
+        var socket = createWebSocket(token);
+        authenticationSuccess(parsedToken, socket);
+      } else {
+        return auth(context.roomId).then(function (_ref2) {
+          var token = _ref2.token;
+
+          if (state.connection.state !== "authenticating") {
+            return;
+          }
+
+          var parsedToken = parseToken(token);
+          var socket = createWebSocket(token);
+          authenticationSuccess(parsedToken, socket);
+          state.token = token;
+        }).catch(function (er) {
+          return authenticationFailure(er);
+        });
+      }
+    },
+    send: function send(messageOrMessages) {
+      if (state.socket == null) {
+        throw new Error("Can't send message if socket is null");
+      }
+
+      state.socket.send(JSON.stringify(messageOrMessages));
+    },
+    delayFlush: function delayFlush(delay) {
+      return setTimeout(tryFlushing, delay);
+    },
+    startHeartbeatInterval: function startHeartbeatInterval() {
+      return setInterval(heartbeat, HEARTBEAT_INTERVAL);
+    },
+    schedulePongTimeout: function schedulePongTimeout() {
+      return setTimeout(pongTimeout, PONG_TIMEOUT);
+    },
+    scheduleReconnect: function scheduleReconnect(delay) {
+      return setTimeout(connect, delay);
+    }
+  };
+
+  function genericSubscribe(callback) {
+    state.listeners.storage.push(callback);
+    return function () {
+      return LiveObject.remove(state.listeners.storage, callback);
+    };
+  }
+
+  function crdtSubscribe(crdt, innerCallback, options) {
+    var cb = function cb(updates) {
+      var relatedUpdates = [];
+
+      for (var _iterator = LiveObject._createForOfIteratorHelperLoose(updates), _step; !(_step = _iterator()).done;) {
+        var update = _step.value;
+
+        if (options != null && options.isDeep && LiveObject.isSameNodeOrChildOf(update.node, crdt)) {
+          relatedUpdates.push(update);
+        } else if (update.node._id === crdt._id) {
+          innerCallback(update.node);
+        }
+      }
+
+      if (options != null && options.isDeep && relatedUpdates.length > 0) {
+        innerCallback(relatedUpdates);
+      }
+    };
+
+    return genericSubscribe(cb);
+  }
+
+  function createOrUpdateRootFromMessage(message) {
+    if (message.items.length === 0) {
+      throw new Error("Internal error: cannot load storage without items");
+    }
+
+    if (state.root) {
+      updateRoot(message.items);
+    } else {
+      state.root = load(message.items);
+    }
+
+    for (var _key in state.defaultStorageRoot) {
+      if (state.root.get(_key) == null) {
+        state.root.set(_key, state.defaultStorageRoot[_key]);
+      }
+    }
+  }
+
+  function buildRootAndParentToChildren(items) {
+    var parentToChildren = new Map();
+    var root = null;
+
+    for (var _iterator2 = LiveObject._createForOfIteratorHelperLoose(items), _step2; !(_step2 = _iterator2()).done;) {
+      var tuple = _step2.value;
+      var parentId = tuple[1].parentId;
+
+      if (parentId == null) {
+        root = tuple;
+      } else {
+        var children = parentToChildren.get(parentId);
+
+        if (children != null) {
+          children.push(tuple);
+        } else {
+          parentToChildren.set(parentId, [tuple]);
+        }
+      }
+    }
+
+    if (root == null) {
+      throw new Error("Root can't be null");
+    }
+
+    return [root, parentToChildren];
+  }
+
+  function updateRoot(items) {
+    if (!state.root) {
+      return;
+    }
+
+    var currentItems = new Map();
+    state.items.forEach(function (liveCrdt, id) {
+      currentItems.set(id, liveCrdt._toSerializedCrdt());
+    });
+    var ops = LiveObject.getTreesDiffOperations(currentItems, new Map(items));
+    var result = apply(ops, false);
+    notify(result.updates);
+  }
+
+  function load(items) {
+    var _buildRootAndParentTo = buildRootAndParentToChildren(items),
+        root = _buildRootAndParentTo[0],
+        parentToChildren = _buildRootAndParentTo[1];
+
+    return LiveObject.LiveObject._deserialize(root, parentToChildren, {
+      getItem: getItem,
+      addItem: addItem,
+      deleteItem: deleteItem,
+      generateId: generateId,
+      generateOpId: generateOpId,
+      dispatch: storageDispatch,
+      roomId: context.roomId
+    });
+  }
+
+  function addItem(id, item) {
+    state.items.set(id, item);
+  }
+
+  function deleteItem(id) {
+    state.items.delete(id);
+  }
+
+  function getItem(id) {
+    return state.items.get(id);
+  }
+
+  function addToUndoStack(historyItem) {
+    if (state.undoStack.length >= 50) {
+      state.undoStack.shift();
+    }
+
+    if (state.isHistoryPaused) {
+      var _state$pausedHistory;
+
+      (_state$pausedHistory = state.pausedHistory).unshift.apply(_state$pausedHistory, historyItem);
+    } else {
+      state.undoStack.push(historyItem);
+    }
+  }
+
+  function storageDispatch(ops, reverse, storageUpdates) {
+    if (state.isBatching) {
+      var _state$batch$ops, _state$batch$reverseO;
+
+      (_state$batch$ops = state.batch.ops).push.apply(_state$batch$ops, ops);
+
+      storageUpdates.forEach(function (value, key) {
+        state.batch.updates.storageUpdates.set(key, LiveObject.mergeStorageUpdates(state.batch.updates.storageUpdates.get(key), value));
+      });
+
+      (_state$batch$reverseO = state.batch.reverseOps).push.apply(_state$batch$reverseO, reverse);
+    } else {
+      addToUndoStack(reverse);
+      state.redoStack = [];
+      dispatch(ops);
+      notify({
+        storageUpdates: storageUpdates
+      });
+    }
+  }
+
+  function notify(_ref3) {
+    var _ref3$storageUpdates = _ref3.storageUpdates,
+        storageUpdates = _ref3$storageUpdates === void 0 ? new Map() : _ref3$storageUpdates,
+        _ref3$presence = _ref3.presence,
+        presence = _ref3$presence === void 0 ? false : _ref3$presence,
+        _ref3$others = _ref3.others,
+        otherEvents = _ref3$others === void 0 ? [] : _ref3$others;
+
+    if (otherEvents.length > 0) {
+      state.others = makeOthers(state.users);
+
+      for (var _iterator3 = LiveObject._createForOfIteratorHelperLoose(otherEvents), _step3; !(_step3 = _iterator3()).done;) {
+        var event = _step3.value;
+
+        for (var _iterator4 = LiveObject._createForOfIteratorHelperLoose(state.listeners.others), _step4; !(_step4 = _iterator4()).done;) {
+          var _listener = _step4.value;
+
+          _listener(state.others, event);
+        }
+      }
+    }
+
+    if (presence) {
+      for (var _iterator5 = LiveObject._createForOfIteratorHelperLoose(state.listeners["my-presence"]), _step5; !(_step5 = _iterator5()).done;) {
+        var _listener2 = _step5.value;
+
+        _listener2(state.me);
+      }
+    }
+
+    if (storageUpdates.size > 0) {
+      for (var _iterator6 = LiveObject._createForOfIteratorHelperLoose(state.listeners.storage), _step6; !(_step6 = _iterator6()).done;) {
+        var subscriber = _step6.value;
+        subscriber(Array.from(storageUpdates.values()));
+      }
+    }
+  }
+
+  function getConnectionId() {
+    if (state.connection.state === "open" || state.connection.state === "connecting") {
+      return state.connection.id;
+    } else if (state.lastConnectionId !== null) {
+      return state.lastConnectionId;
+    }
+
+    throw new Error("Internal. Tried to get connection id but connection was never open");
+  }
+
+  function generateId() {
+    return getConnectionId() + ":" + state.clock++;
+  }
+
+  function generateOpId() {
+    return getConnectionId() + ":" + state.opClock++;
+  }
+
+  function apply(item, isLocal) {
+    var result = {
+      reverse: [],
+      updates: {
+        storageUpdates: new Map(),
+        presence: false
+      }
+    };
+    var createdNodeIds = new Set();
+
+    for (var _iterator7 = LiveObject._createForOfIteratorHelperLoose(item), _step7; !(_step7 = _iterator7()).done;) {
+      var op = _step7.value;
+
+      if (op.type === "presence") {
+        var reverse = {
+          type: "presence",
+          data: {}
+        };
+
+        for (var _key2 in op.data) {
+          reverse.data[_key2] = state.me[_key2];
+        }
+
+        state.me = LiveObject._extends({}, state.me, op.data);
+
+        if (state.buffer.presence == null) {
+          state.buffer.presence = op.data;
+        } else {
+          for (var _key3 in op.data) {
+            state.buffer.presence[_key3] = op.data[_key3];
+          }
+        }
+
+        result.reverse.unshift(reverse);
+        result.updates.presence = true;
+      } else {
+        if (isLocal && !op.opId) {
+          op.opId = generateOpId();
+        }
+
+        var applyOpResult = applyOp(op, isLocal);
+
+        if (applyOpResult.modified) {
+          var _applyOpResult$modifi;
+
+          var parentId = (_applyOpResult$modifi = applyOpResult.modified.node._parent) == null ? void 0 : _applyOpResult$modifi._id;
+
+          if (!createdNodeIds.has(parentId)) {
+            var _result$reverse;
+
+            result.updates.storageUpdates.set(applyOpResult.modified.node._id, LiveObject.mergeStorageUpdates(result.updates.storageUpdates.get(applyOpResult.modified.node._id), applyOpResult.modified));
+
+            (_result$reverse = result.reverse).unshift.apply(_result$reverse, applyOpResult.reverse);
+          }
+
+          if (op.type === LiveObject.OpType.CreateList || op.type === LiveObject.OpType.CreateMap || op.type === LiveObject.OpType.CreateObject) {
+            createdNodeIds.add(applyOpResult.modified.node._id);
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  function applyOp(op, isLocal) {
+    if (op.opId) {
+      state.offlineOperations.delete(op.opId);
+    }
+
+    switch (op.type) {
+      case LiveObject.OpType.DeleteObjectKey:
+      case LiveObject.OpType.UpdateObject:
+      case LiveObject.OpType.DeleteCrdt:
+        {
+          var item = state.items.get(op.id);
+
+          if (item == null) {
+            return {
+              modified: false
+            };
+          }
+
+          return item._apply(op, isLocal);
+        }
+
+      case LiveObject.OpType.SetParentKey:
+        {
+          var _item = state.items.get(op.id);
+
+          if (_item == null) {
+            return {
+              modified: false
+            };
+          }
+
+          if (_item._parent instanceof LiveObject.LiveList) {
+            var previousKey = _item._parentKey;
+
+            if (previousKey === op.parentKey) {
+              return {
+                modified: false
+              };
+            } else {
+              return _item._parent._setChildKey(op.parentKey, _item, previousKey);
+            }
+          }
+
+          return {
+            modified: false
+          };
+        }
+
+      case LiveObject.OpType.CreateObject:
+      case LiveObject.OpType.CreateList:
+      case LiveObject.OpType.CreateMap:
+      case LiveObject.OpType.CreateRegister:
+        {
+          var parent = state.items.get(op.parentId);
+
+          if (parent == null) {
+            return {
+              modified: false
+            };
+          }
+
+          return parent._attachChild(op, isLocal);
+        }
+    }
+  }
+
+  function subscribe(firstParam, listener, options) {
+    if (firstParam instanceof LiveObject.AbstractCrdt) {
+      return crdtSubscribe(firstParam, listener, options);
+    } else if (typeof firstParam === "function") {
+      return genericSubscribe(firstParam);
+    } else if (!isValidRoomEventType(firstParam)) {
+      throw new Error("\"" + firstParam + "\" is not a valid event name");
+    }
+
+    state.listeners[firstParam].push(listener);
+    return function () {
+      var callbacks = state.listeners[firstParam];
+      LiveObject.remove(callbacks, listener);
+    };
+  }
+
+  function unsubscribe(event, callback) {
+    console.warn("unsubscribe is depreacted and will be removed in a future version.\nuse the callback returned by subscribe instead.\nSee v0.13 release notes for more information.\n");
+
+    if (!isValidRoomEventType(event)) {
+      throw new Error("\"" + event + "\" is not a valid event name");
+    }
+
+    var callbacks = state.listeners[event];
+    LiveObject.remove(callbacks, callback);
+  }
+
+  function getConnectionState() {
+    return state.connection.state;
+  }
+
+  function getSelf() {
+    return state.connection.state === "open" || state.connection.state === "connecting" ? {
+      connectionId: state.connection.id,
+      id: state.connection.userId,
+      info: state.connection.userInfo,
+      presence: getPresence()
+    } : null;
+  }
+
+  function connect() {
+    if (state.connection.state !== "closed" && state.connection.state !== "unavailable") {
+      return null;
+    }
+
+    var auth = prepareAuthEndpoint(context.authentication, context.fetchPolyfill);
+    var createWebSocket = prepareCreateWebSocket(context.liveblocksServer, context.WebSocketPolyfill);
+    updateConnection({
+      state: "authenticating"
+    });
+    effects.authenticate(auth, createWebSocket);
+  }
+
+  function updatePresence(overrides, options) {
+    var oldValues = {};
+
+    if (state.buffer.presence == null) {
+      state.buffer.presence = {};
+    }
+
+    for (var _key4 in overrides) {
+      state.buffer.presence[_key4] = overrides[_key4];
+      oldValues[_key4] = state.me[_key4];
+    }
+
+    state.me = LiveObject._extends({}, state.me, overrides);
+
+    if (state.isBatching) {
+      if (options != null && options.addToHistory) {
+        state.batch.reverseOps.push({
+          type: "presence",
+          data: oldValues
+        });
+      }
+
+      state.batch.updates.presence = true;
+    } else {
+      tryFlushing();
+
+      if (options != null && options.addToHistory) {
+        addToUndoStack([{
+          type: "presence",
+          data: oldValues
+        }]);
+      }
+
+      notify({
+        presence: true
+      });
+    }
+  }
+
+  function authenticationSuccess(token, socket) {
+    socket.addEventListener("message", onMessage);
+    socket.addEventListener("open", onOpen);
+    socket.addEventListener("close", onClose);
+    socket.addEventListener("error", onError);
+    updateConnection({
+      state: "connecting",
+      id: token.actor,
+      userInfo: token.info,
+      userId: token.id
+    });
+    state.idFactory = makeIdFactory(token.actor);
+    state.socket = socket;
+  }
+
+  function authenticationFailure(error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.error("Call to authentication endpoint failed", error);
+    }
+
+    state.token = null;
+    updateConnection({
+      state: "unavailable"
+    });
+    state.numberOfRetry++;
+    state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
+  }
+
+  function onVisibilityChange(visibilityState) {
+    if (visibilityState === "visible" && state.connection.state === "open") {
+      heartbeat();
+    }
+  }
+
+  function onUpdatePresenceMessage(message) {
+    var user = state.users[message.actor];
+
+    if (message.targetActor === undefined && user != null && !user._hasReceivedInitialPresence) {
+      return undefined;
+    }
+
+    if (user == null) {
+      state.users[message.actor] = {
+        connectionId: message.actor,
+        presence: message.data,
+        _hasReceivedInitialPresence: true
+      };
+    } else {
+      state.users[message.actor] = {
+        id: user.id,
+        info: user.info,
+        connectionId: message.actor,
+        presence: LiveObject._extends({}, user.presence, message.data),
+        _hasReceivedInitialPresence: true
+      };
+    }
+
+    return {
+      type: "update",
+      updates: message.data,
+      user: state.users[message.actor]
+    };
+  }
+
+  function onUserLeftMessage(message) {
+    var userLeftMessage = message;
+    var user = state.users[userLeftMessage.actor];
+
+    if (user) {
+      delete state.users[userLeftMessage.actor];
+      return {
+        type: "leave",
+        user: user
+      };
+    }
+
+    return null;
+  }
+
+  function onRoomStateMessage(message) {
+    var newUsers = {};
+
+    for (var _key5 in message.users) {
+      var _connectionId = Number.parseInt(_key5);
+
+      var user = message.users[_key5];
+      newUsers[_connectionId] = {
+        connectionId: _connectionId,
+        info: user.info,
+        id: user.id
+      };
+    }
+
+    state.users = newUsers;
+    return {
+      type: "reset"
+    };
+  }
+
+  function onNavigatorOnline() {
+    if (state.connection.state === "unavailable") {
+      reconnect();
+    }
+  }
+
+  function onEvent(message) {
+    for (var _iterator8 = LiveObject._createForOfIteratorHelperLoose(state.listeners.event), _step8; !(_step8 = _iterator8()).done;) {
+      var _listener3 = _step8.value;
+
+      _listener3({
+        connectionId: message.actor,
+        event: message.event
+      });
+    }
+  }
+
+  function onUserJoinedMessage(message) {
+    state.users[message.actor] = {
+      connectionId: message.actor,
+      info: message.info,
+      id: message.id,
+      _hasReceivedInitialPresence: true
+    };
+
+    if (state.me) {
+      state.buffer.messages.push({
+        type: LiveObject.ClientMessageType.UpdatePresence,
+        data: state.me,
+        targetActor: message.actor
+      });
+      tryFlushing();
+    }
+
+    return {
+      type: "enter",
+      user: state.users[message.actor]
+    };
+  }
+
+  function parseServerMessage(data) {
+    if (!LiveObject.isJsonObject(data)) {
+      return null;
+    }
+
+    return data;
+  }
+
+  function parseServerMessages(text) {
+    var data = LiveObject.parseJson(text);
+
+    if (data === undefined) {
+      return null;
+    } else if (LiveObject.isJsonArray(data)) {
+      return LiveObject.compact(data.map(function (item) {
+        return parseServerMessage(item);
+      }));
+    } else {
+      return LiveObject.compact([parseServerMessage(data)]);
+    }
+  }
+
+  function onMessage(event) {
+    if (event.data === "pong") {
+      clearTimeout(state.timeoutHandles.pongTimeout);
+      return;
+    }
+
+    var messages = parseServerMessages(event.data);
+
+    if (messages === null || messages.length === 0) {
+      return;
+    }
+
+    var updates = {
+      storageUpdates: new Map(),
+      others: []
+    };
+
+    for (var _iterator9 = LiveObject._createForOfIteratorHelperLoose(messages), _step9; !(_step9 = _iterator9()).done;) {
+      var message = _step9.value;
+
+      switch (message.type) {
+        case LiveObject.ServerMessageType.UserJoined:
+          {
+            updates.others.push(onUserJoinedMessage(message));
+            break;
+          }
+
+        case LiveObject.ServerMessageType.UpdatePresence:
+          {
+            var othersPresenceUpdate = onUpdatePresenceMessage(message);
+
+            if (othersPresenceUpdate) {
+              updates.others.push(othersPresenceUpdate);
+            }
+
+            break;
+          }
+
+        case LiveObject.ServerMessageType.Event:
+          {
+            onEvent(message);
+            break;
+          }
+
+        case LiveObject.ServerMessageType.UserLeft:
+          {
+            var _event = onUserLeftMessage(message);
+
+            if (_event) {
+              updates.others.push(_event);
+            }
+
+            break;
+          }
+
+        case LiveObject.ServerMessageType.RoomState:
+          {
+            updates.others.push(onRoomStateMessage(message));
+            break;
+          }
+
+        case LiveObject.ServerMessageType.InitialStorageState:
+          {
+            var offlineOps = new Map(state.offlineOperations);
+            createOrUpdateRootFromMessage(message);
+            applyAndSendOfflineOps(offlineOps);
+            _getInitialStateResolver == null ? void 0 : _getInitialStateResolver();
+            break;
+          }
+
+        case LiveObject.ServerMessageType.UpdateStorage:
+          {
+            var applyResult = apply(message.ops, false);
+            applyResult.updates.storageUpdates.forEach(function (value, key) {
+              updates.storageUpdates.set(key, LiveObject.mergeStorageUpdates(updates.storageUpdates.get(key), value));
+            });
+            break;
+          }
+      }
+    }
+
+    notify(updates);
+  }
+
+  function onClose(event) {
+    state.socket = null;
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    clearInterval(state.intervalHandles.heartbeat);
+
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+
+    clearTimeout(state.timeoutHandles.reconnect);
+    state.users = {};
+    notify({
+      others: [{
+        type: "reset"
+      }]
+    });
+
+    if (event.code >= 4000 && event.code <= 4100) {
+      updateConnection({
+        state: "failed"
+      });
+      var error = new LiveblocksError(event.reason, event.code);
+
+      for (var _iterator10 = LiveObject._createForOfIteratorHelperLoose(state.listeners.error), _step10; !(_step10 = _iterator10()).done;) {
+        var _listener4 = _step10.value;
+
+        _listener4(error);
+      }
+
+      var _delay = getRetryDelay(true);
+
+      state.numberOfRetry++;
+
+      if (process.env.NODE_ENV !== "production") {
+        console.error("Connection to Liveblocks websocket server closed. Reason: " + error.message + " (code: " + error.code + "). Retrying in " + _delay + "ms.");
+      }
+
+      updateConnection({
+        state: "unavailable"
+      });
+      state.timeoutHandles.reconnect = effects.scheduleReconnect(_delay);
+    } else if (event.code === LiveObject.WebsocketCloseCodes.CLOSE_WITHOUT_RETRY) {
+      updateConnection({
+        state: "closed"
+      });
+    } else {
+      var _delay2 = getRetryDelay();
+
+      state.numberOfRetry++;
+
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("Connection to Liveblocks websocket server closed (code: " + event.code + "). Retrying in " + _delay2 + "ms.");
+      }
+
+      updateConnection({
+        state: "unavailable"
+      });
+      state.timeoutHandles.reconnect = effects.scheduleReconnect(_delay2);
+    }
+  }
+
+  function updateConnection(connection) {
+    state.connection = connection;
+
+    for (var _iterator11 = LiveObject._createForOfIteratorHelperLoose(state.listeners.connection), _step11; !(_step11 = _iterator11()).done;) {
+      var _listener5 = _step11.value;
+
+      _listener5(connection.state);
+    }
+  }
+
+  function getRetryDelay(slow) {
+    if (slow === void 0) {
+      slow = false;
+    }
+
+    if (slow) {
+      return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
+    }
+
+    return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
+  }
+
+  function onError() {}
+
+  function onOpen() {
+    clearInterval(state.intervalHandles.heartbeat);
+    state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
+
+    if (state.connection.state === "connecting") {
+      updateConnection(LiveObject._extends({}, state.connection, {
+        state: "open"
+      }));
+      state.numberOfRetry = 0;
+
+      if (state.lastConnectionId !== undefined) {
+        state.buffer.presence = state.me;
+        tryFlushing();
+      }
+
+      state.lastConnectionId = state.connection.id;
+
+      if (state.root) {
+        state.buffer.messages.push({
+          type: LiveObject.ClientMessageType.FetchStorage
+        });
+      }
+
+      tryFlushing();
+    }
+  }
+
+  function heartbeat() {
+    if (state.socket == null) {
+      return;
+    }
+
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
+
+    if (state.socket.readyState === state.socket.OPEN) {
+      state.socket.send("ping");
+    }
+  }
+
+  function pongTimeout() {
+    reconnect();
+  }
+
+  function reconnect() {
+    if (state.socket) {
+      state.socket.removeEventListener("open", onOpen);
+      state.socket.removeEventListener("message", onMessage);
+      state.socket.removeEventListener("close", onClose);
+      state.socket.removeEventListener("error", onError);
+      state.socket.close();
+      state.socket = null;
+    }
+
+    updateConnection({
+      state: "unavailable"
+    });
+    clearTimeout(state.timeoutHandles.pongTimeout);
+
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+
+    clearTimeout(state.timeoutHandles.reconnect);
+    clearInterval(state.intervalHandles.heartbeat);
+    connect();
+  }
+
+  function applyAndSendOfflineOps(offlineOps) {
+    if (offlineOps.size === 0) {
+      return;
+    }
+
+    var messages = [];
+    var ops = Array.from(offlineOps.values());
+    var result = apply(ops, true);
+    messages.push({
+      type: LiveObject.ClientMessageType.UpdateStorage,
+      ops: ops
+    });
+    notify(result.updates);
+    effects.send(messages);
+  }
+
+  function tryFlushing() {
+    var storageOps = state.buffer.storageOperations;
+
+    if (storageOps.length > 0) {
+      storageOps.forEach(function (op) {
+        state.offlineOperations.set(op.opId, op);
+      });
+    }
+
+    if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
+      state.buffer.storageOperations = [];
+      return;
+    }
+
+    var now = Date.now();
+    var elapsedTime = now - state.lastFlushTime;
+
+    if (elapsedTime > context.throttleDelay) {
+      var _messages = flushDataToMessages(state);
+
+      if (_messages.length === 0) {
+        return;
+      }
+
+      effects.send(_messages);
+      state.buffer = {
+        messages: [],
+        storageOperations: [],
+        presence: null
+      };
+      state.lastFlushTime = now;
+    } else {
+      if (state.timeoutHandles.flush != null) {
+        clearTimeout(state.timeoutHandles.flush);
+      }
+
+      state.timeoutHandles.flush = effects.delayFlush(context.throttleDelay - (now - state.lastFlushTime));
+    }
+  }
+
+  function flushDataToMessages(state) {
+    var messages = [];
+
+    if (state.buffer.presence) {
+      messages.push({
+        type: LiveObject.ClientMessageType.UpdatePresence,
+        data: state.buffer.presence
+      });
+    }
+
+    for (var _iterator12 = LiveObject._createForOfIteratorHelperLoose(state.buffer.messages), _step12; !(_step12 = _iterator12()).done;) {
+      var event = _step12.value;
+      messages.push(event);
+    }
+
+    if (state.buffer.storageOperations.length > 0) {
+      messages.push({
+        type: LiveObject.ClientMessageType.UpdateStorage,
+        ops: state.buffer.storageOperations
+      });
+    }
+
+    return messages;
+  }
+
+  function disconnect() {
+    if (state.socket) {
+      state.socket.removeEventListener("open", onOpen);
+      state.socket.removeEventListener("message", onMessage);
+      state.socket.removeEventListener("close", onClose);
+      state.socket.removeEventListener("error", onError);
+      state.socket.close();
+      state.socket = null;
+    }
+
+    updateConnection({
+      state: "closed"
+    });
+
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+
+    clearTimeout(state.timeoutHandles.reconnect);
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    clearInterval(state.intervalHandles.heartbeat);
+    state.users = {};
+    notify({
+      others: [{
+        type: "reset"
+      }]
+    });
+    clearListeners();
+  }
+
+  function clearListeners() {
+    for (var _key6 in state.listeners) {
+      state.listeners[_key6] = [];
+    }
+  }
+
+  function getPresence() {
+    return state.me;
+  }
+
+  function getOthers() {
+    return state.others;
+  }
+
+  function broadcastEvent(event, options) {
+    if (options === void 0) {
+      options = {
+        shouldQueueEventIfNotReady: false
+      };
+    }
+
+    if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
+      return;
+    }
+
+    state.buffer.messages.push({
+      type: LiveObject.ClientMessageType.ClientEvent,
+      event: event
+    });
+    tryFlushing();
+  }
+
+  function dispatch(ops) {
+    var _state$buffer$storage;
+
+    (_state$buffer$storage = state.buffer.storageOperations).push.apply(_state$buffer$storage, ops);
+
+    tryFlushing();
+  }
+
+  var _getInitialStatePromise = null;
+  var _getInitialStateResolver = null;
+
+  function getStorage() {
+    if (state.root) {
+      return new Promise(function (resolve) {
+        return resolve({
+          root: state.root
+        });
+      });
+    }
+
+    if (_getInitialStatePromise == null) {
+      state.buffer.messages.push({
+        type: LiveObject.ClientMessageType.FetchStorage
+      });
+      tryFlushing();
+      _getInitialStatePromise = new Promise(function (resolve) {
+        return _getInitialStateResolver = resolve;
+      });
+    }
+
+    return _getInitialStatePromise.then(function () {
+      return {
+        root: state.root
+      };
+    });
+  }
+
+  function undo() {
+    if (state.isBatching) {
+      throw new Error("undo is not allowed during a batch");
+    }
+
+    var historyItem = state.undoStack.pop();
+
+    if (historyItem == null) {
+      return;
+    }
+
+    state.isHistoryPaused = false;
+    var result = apply(historyItem, true);
+    notify(result.updates);
+    state.redoStack.push(result.reverse);
+
+    for (var _iterator13 = LiveObject._createForOfIteratorHelperLoose(historyItem), _step13; !(_step13 = _iterator13()).done;) {
+      var op = _step13.value;
+
+      if (op.type !== "presence") {
+        state.buffer.storageOperations.push(op);
+      }
+    }
+
+    tryFlushing();
+  }
+
+  function redo() {
+    if (state.isBatching) {
+      throw new Error("redo is not allowed during a batch");
+    }
+
+    var historyItem = state.redoStack.pop();
+
+    if (historyItem == null) {
+      return;
+    }
+
+    state.isHistoryPaused = false;
+    var result = apply(historyItem, true);
+    notify(result.updates);
+    state.undoStack.push(result.reverse);
+
+    for (var _iterator14 = LiveObject._createForOfIteratorHelperLoose(historyItem), _step14; !(_step14 = _iterator14()).done;) {
+      var op = _step14.value;
+
+      if (op.type !== "presence") {
+        state.buffer.storageOperations.push(op);
+      }
+    }
+
+    tryFlushing();
+  }
+
+  function batch(callback) {
+    if (state.isBatching) {
+      throw new Error("batch should not be called during a batch");
+    }
+
+    state.isBatching = true;
+
+    try {
+      callback();
+    } finally {
+      state.isBatching = false;
+
+      if (state.batch.reverseOps.length > 0) {
+        addToUndoStack(state.batch.reverseOps);
+      }
+
+      if (state.batch.ops.length > 0) {
+        state.redoStack = [];
+      }
+
+      if (state.batch.ops.length > 0) {
+        dispatch(state.batch.ops);
+      }
+
+      notify(state.batch.updates);
+      state.batch = {
+        ops: [],
+        reverseOps: [],
+        updates: {
+          others: [],
+          storageUpdates: new Map(),
+          presence: false
+        }
+      };
+      tryFlushing();
+    }
+  }
+
+  function pauseHistory() {
+    state.pausedHistory = [];
+    state.isHistoryPaused = true;
+  }
+
+  function resumeHistory() {
+    state.isHistoryPaused = false;
+
+    if (state.pausedHistory.length > 0) {
+      addToUndoStack(state.pausedHistory);
+    }
+
+    state.pausedHistory = [];
+  }
+
+  function simulateSocketClose() {
+    if (state.socket) {
+      state.socket.close();
+    }
+  }
+
+  function simulateSendCloseEvent(event) {
+    if (state.socket) {
+      onClose(event);
+    }
+  }
+
+  return {
+    onClose: onClose,
+    onMessage: onMessage,
+    authenticationSuccess: authenticationSuccess,
+    heartbeat: heartbeat,
+    onNavigatorOnline: onNavigatorOnline,
+    simulateSocketClose: simulateSocketClose,
+    simulateSendCloseEvent: simulateSendCloseEvent,
+    onVisibilityChange: onVisibilityChange,
+    getUndoStack: function getUndoStack() {
+      return state.undoStack;
+    },
+    getItemsCount: function getItemsCount() {
+      return state.items.size;
+    },
+    connect: connect,
+    disconnect: disconnect,
+    subscribe: subscribe,
+    unsubscribe: unsubscribe,
+    updatePresence: updatePresence,
+    broadcastEvent: broadcastEvent,
+    batch: batch,
+    undo: undo,
+    redo: redo,
+    pauseHistory: pauseHistory,
+    resumeHistory: resumeHistory,
+    getStorage: getStorage,
+    selectors: {
+      getConnectionState: getConnectionState,
+      getSelf: getSelf,
+      getPresence: getPresence,
+      getOthers: getOthers
+    }
+  };
+}
+function defaultState(me, defaultStorageRoot) {
+  return {
+    connection: {
+      state: "closed"
+    },
+    token: null,
+    lastConnectionId: null,
+    socket: null,
+    listeners: {
+      event: [],
+      others: [],
+      "my-presence": [],
+      error: [],
+      connection: [],
+      storage: []
+    },
+    numberOfRetry: 0,
+    lastFlushTime: 0,
+    timeoutHandles: {
+      flush: null,
+      reconnect: 0,
+      pongTimeout: 0
+    },
+    buffer: {
+      presence: me == null ? {} : me,
+      messages: [],
+      storageOperations: []
+    },
+    intervalHandles: {
+      heartbeat: 0
+    },
+    me: me == null ? {} : me,
+    users: {},
+    others: makeOthers({}),
+    defaultStorageRoot: defaultStorageRoot,
+    idFactory: null,
+    clock: 0,
+    opClock: 0,
+    items: new Map(),
+    root: undefined,
+    undoStack: [],
+    redoStack: [],
+    isHistoryPaused: false,
+    pausedHistory: [],
+    isBatching: false,
+    batch: {
+      ops: [],
+      updates: {
+        storageUpdates: new Map(),
+        presence: false,
+        others: []
+      },
+      reverseOps: []
+    },
+    offlineOperations: new Map()
+  };
+}
+function createRoom(options, context) {
+  var state = defaultState(options.defaultPresence, options.defaultStorageRoot);
+  var machine = makeStateMachine(state, context);
+  var room = {
+    id: context.roomId,
+    getConnectionState: machine.selectors.getConnectionState,
+    getSelf: machine.selectors.getSelf,
+    subscribe: machine.subscribe,
+    unsubscribe: machine.unsubscribe,
+    getPresence: machine.selectors.getPresence,
+    updatePresence: machine.updatePresence,
+    getOthers: machine.selectors.getOthers,
+    broadcastEvent: machine.broadcastEvent,
+    getStorage: machine.getStorage,
+    batch: machine.batch,
+    history: {
+      undo: machine.undo,
+      redo: machine.redo,
+      pause: machine.pauseHistory,
+      resume: machine.resumeHistory
+    },
+    internalDevTools: {
+      closeWebsocket: machine.simulateSocketClose,
+      sendCloseEvent: machine.simulateSendCloseEvent
+    }
+  };
+  return {
+    connect: machine.connect,
+    disconnect: machine.disconnect,
+    onNavigatorOnline: machine.onNavigatorOnline,
+    onVisibilityChange: machine.onVisibilityChange,
+    room: room
+  };
+}
+
+var LiveblocksError = function (_Error) {
+  LiveObject._inheritsLoose(LiveblocksError, _Error);
+
+  function LiveblocksError(message, code) {
+    var _this;
+
+    _this = _Error.call(this, message) || this;
+    _this.code = code;
+    return _this;
+  }
+
+  return LiveblocksError;
+}(LiveObject._wrapNativeSuper(Error));
+
+function parseToken(token) {
+  var tokenParts = token.split(".");
+
+  if (tokenParts.length !== 3) {
+    throw new Error("Authentication error. Liveblocks could not parse the response of your authentication endpoint");
+  }
+
+  var data = LiveObject.parseJson(atob(tokenParts[1]));
+
+  if (data !== undefined && LiveObject.isJsonObject(data) && typeof data.actor === "number" && (data.id === undefined || typeof data.id === "string")) {
+    return {
+      actor: data.actor,
+      id: data.id,
+      info: data.info
+    };
+  }
+
+  throw new Error("Authentication error. Liveblocks could not parse the response of your authentication endpoint");
+}
+
+function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
+  if (typeof window === "undefined" && WebSocketPolyfill == null) {
+    throw new Error("To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill.");
+  }
+
+  var ws = WebSocketPolyfill || WebSocket;
+  return function (token) {
+    return new ws(liveblocksServer + "/?token=" + token);
+  };
+}
+
+function prepareAuthEndpoint(authentication, fetchPolyfill) {
+  if (authentication.type === "public") {
+    if (typeof window === "undefined" && fetchPolyfill == null) {
+      throw new Error("To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill.");
+    }
+
+    return function (room) {
+      return fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+        room: room,
+        publicApiKey: authentication.publicApiKey
+      });
+    };
+  }
+
+  if (authentication.type === "private") {
+    if (typeof window === "undefined" && fetchPolyfill == null) {
+      throw new Error("To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill.");
+    }
+
+    return function (room) {
+      return fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+        room: room
+      });
+    };
+  }
+
+  if (authentication.type === "custom") {
+    return authentication.callback;
+  }
+
+  throw new Error("Internal error. Unexpected authentication type");
+}
+
+function fetchAuthEndpoint(fetch, endpoint, body) {
+  return fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  }).then(function (res) {
+    if (!res.ok) {
+      throw new AuthenticationError("Expected a status 200 but got " + res.status + " when doing a POST request on \"" + endpoint + "\"");
+    }
+
+    return res.json().catch(function (er) {
+      throw new AuthenticationError("Expected a json when doing a POST request on \"" + endpoint + "\". " + er);
+    });
+  }).then(function (authResponse) {
+    if (typeof authResponse.token !== "string") {
+      throw new AuthenticationError("Expected a json with a string token when doing a POST request on \"" + endpoint + "\", but got " + JSON.stringify(authResponse));
+    }
+
+    return authResponse;
+  });
+}
+
+var AuthenticationError = function (_Error2) {
+  LiveObject._inheritsLoose(AuthenticationError, _Error2);
+
+  function AuthenticationError(message) {
+    return _Error2.call(this, message) || this;
+  }
+
+  return AuthenticationError;
+}(LiveObject._wrapNativeSuper(Error));
+
+function createClient(options) {
+  var clientOptions = options;
+  var throttleDelay = getThrottleDelayFromOptions(options);
+  var rooms = new Map();
+
+  function getRoom(roomId) {
+    var internalRoom = rooms.get(roomId);
+    return internalRoom ? internalRoom.room : null;
+  }
+
+  function enter(roomId, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var internalRoom = rooms.get(roomId);
+
+    if (internalRoom) {
+      return internalRoom.room;
+    }
+
+    internalRoom = createRoom({
+      defaultPresence: options.defaultPresence,
+      defaultStorageRoot: options.defaultStorageRoot
+    }, {
+      roomId: roomId,
+      throttleDelay: throttleDelay,
+      WebSocketPolyfill: clientOptions.WebSocketPolyfill,
+      fetchPolyfill: clientOptions.fetchPolyfill,
+      liveblocksServer: clientOptions.liveblocksServer || "wss://liveblocks.net/v5",
+      authentication: prepareAuthentication(clientOptions)
+    });
+    rooms.set(roomId, internalRoom);
+
+    if (!options.DO_NOT_USE_withoutConnecting) {
+      internalRoom.connect();
+    }
+
+    return internalRoom.room;
+  }
+
+  function leave(roomId) {
+    var room = rooms.get(roomId);
+
+    if (room) {
+      room.disconnect();
+      rooms.delete(roomId);
+    }
+  }
+
+  if (typeof window !== "undefined") {
+    window.addEventListener("online", function () {
+      for (var _iterator = LiveObject._createForOfIteratorHelperLoose(rooms), _step; !(_step = _iterator()).done;) {
+        var _step$value = _step.value,
+            room = _step$value[1];
+        room.onNavigatorOnline();
+      }
+    });
+  }
+
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", function () {
+      for (var _iterator2 = LiveObject._createForOfIteratorHelperLoose(rooms), _step2; !(_step2 = _iterator2()).done;) {
+        var _step2$value = _step2.value,
+            room = _step2$value[1];
+        room.onVisibilityChange(document.visibilityState);
+      }
+    });
+  }
+
+  return {
+    getRoom: getRoom,
+    enter: enter,
+    leave: leave
+  };
+}
+
+function getThrottleDelayFromOptions(options) {
+  if (options.throttle === undefined) {
+    return 100;
+  }
+
+  if (typeof options.throttle !== "number" || options.throttle < 80 || options.throttle > 1000) {
+    throw new Error("throttle should be a number between 80 and 1000.");
+  }
+
+  return options.throttle;
+}
+
+function prepareAuthentication(clientOptions) {
+  if (typeof clientOptions.publicApiKey === "string") {
+    return {
+      type: "public",
+      publicApiKey: clientOptions.publicApiKey,
+      url: clientOptions.publicAuthorizeEndpoint || "https://liveblocks.io/api/public/authorize"
+    };
+  } else if (typeof clientOptions.authEndpoint === "string") {
+    return {
+      type: "private",
+      url: clientOptions.authEndpoint
+    };
+  } else if (typeof clientOptions.authEndpoint === "function") {
+    return {
+      type: "custom",
+      callback: clientOptions.authEndpoint
+    };
+  }
+
+  throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
+}
+
+function lsonObjectToJson(obj) {
+  var result = {};
+
+  for (var _key in obj) {
+    var val = obj[_key];
+
+    if (val !== undefined) {
+      result[_key] = lsonToJson(val);
+    }
+  }
+
+  return result;
+}
+
+function liveObjectToJson(liveObject) {
+  return lsonObjectToJson(liveObject.toObject());
+}
+
+function liveMapToJson(map) {
+  var result = {};
+
+  for (var _iterator = LiveObject._createForOfIteratorHelperLoose(map.entries()), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        _key2 = _step$value[0],
+        value = _step$value[1];
+    result[_key2] = 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.LiveObject) {
+    return liveObjectToJson(value);
+  } else if (value instanceof LiveObject.LiveList) {
+    return liveListToJson(value);
+  } else if (value instanceof LiveObject.LiveMap) {
+    return liveMapToJson(value);
+  } else if (value instanceof LiveObject.LiveRegister) {
+    return value.data;
+  } else if (value instanceof LiveObject.AbstractCrdt) {
+    throw new Error("Unhandled subclass of AbstractCrdt encountered");
+  }
+
+  if (Array.isArray(value)) {
+    return lsonListToJson(value);
+  } else if (isPlainObject(value)) {
+    return lsonObjectToJson(value);
+  }
+
+  return value;
+}
+
+function isPlainObject(obj) {
+  return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
+}
+
+function anyToCrdt(obj) {
+  if (obj == null) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return new LiveObject.LiveList(obj.map(anyToCrdt));
+  }
+
+  if (isPlainObject(obj)) {
+    var init = {};
+
+    for (var _key3 in obj) {
+      init[_key3] = anyToCrdt(obj[_key3]);
+    }
+
+    return new LiveObject.LiveObject(init);
+  }
+
+  return obj;
+}
+
+function patchLiveList(liveList, prev, next) {
+  var i = 0;
+  var prevEnd = prev.length - 1;
+  var nextEnd = next.length - 1;
+  var prevNode = prev[0];
+  var 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(anyToCrdt(next[i]), i);
+        i++;
+      }
+    }
+  } else if (i > nextEnd) {
+    var localI = i;
+
+    while (localI <= prevEnd) {
+      liveList.delete(i);
+      localI++;
+    }
+  } else {
+    while (i <= prevEnd && i <= nextEnd) {
+      prevNode = prev[i];
+      nextNode = next[i];
+      var liveListNode = liveList.get(i);
+
+      if (liveListNode instanceof LiveObject.LiveObject && isPlainObject(prevNode) && isPlainObject(nextNode)) {
+        patchLiveObject(liveListNode, prevNode, nextNode);
+      } else {
+        liveList.set(i, anyToCrdt(nextNode));
+      }
+
+      i++;
+    }
+
+    while (i <= nextEnd) {
+      liveList.insert(anyToCrdt(next[i]), i);
+      i++;
+    }
+
+    var _localI = i;
+
+    while (_localI <= prevEnd) {
+      liveList.delete(i);
+      _localI++;
+    }
+  }
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+  if (process.env.NODE_ENV !== "production") {
+    var nonSerializableValue = LiveObject.findNonSerializableValue(next);
+
+    if (nonSerializableValue) {
+      console.error("New state path: '" + nonSerializableValue.path + "' value: '" + nonSerializableValue.value + "' is not serializable.\nOnly serializable value can be synced with Liveblocks.");
+      return;
+    }
+  }
+
+  var value = liveObject.get(key);
+
+  if (next === undefined) {
+    liveObject.delete(key);
+  } else if (value === undefined) {
+    liveObject.set(key, anyToCrdt(next));
+  } else if (prev === next) {
+    return;
+  } else if (value instanceof LiveObject.LiveList && Array.isArray(prev) && Array.isArray(next)) {
+    patchLiveList(value, prev, next);
+  } else if (value instanceof LiveObject.LiveObject && isPlainObject(prev) && isPlainObject(next)) {
+    patchLiveObject(value, prev, next);
+  } else {
+    liveObject.set(key, anyToCrdt(next));
+  }
+}
+function patchLiveObject(root, prev, next) {
+  var updates = {};
+
+  for (var _key4 in next) {
+    patchLiveObjectKey(root, _key4, prev[_key4], next[_key4]);
+  }
+
+  for (var _key5 in prev) {
+    if (next[_key5] === undefined) {
+      root.delete(_key5);
+    }
+  }
+
+  if (Object.keys(updates).length > 0) {
+    root.update(updates);
+  }
+}
+
+function getParentsPath(node) {
+  var path = [];
+
+  while (node._parentKey != null && node._parent != null) {
+    if (node._parent instanceof LiveObject.LiveList) {
+      path.push(node._parent._indexOfPosition(node._parentKey));
+    } else {
+      path.push(node._parentKey);
+    }
+
+    node = node._parent;
+  }
+
+  return path;
+}
+
+function patchImmutableObject(state, updates) {
+  return updates.reduce(function (state, update) {
+    return patchImmutableObjectWithUpdate(state, update);
+  }, state);
+}
+
+function patchImmutableObjectWithUpdate(state, update) {
+  var path = getParentsPath(update.node);
+  return patchImmutableNode(state, path, update);
+}
+
+function patchImmutableNode(state, path, update) {
+  var pathItem = path.pop();
+
+  if (pathItem === undefined) {
+    switch (update.type) {
+      case "LiveObject":
+        {
+          if (typeof state !== "object") {
+            throw new Error("Internal: received update on LiveObject but state was not an object");
+          }
+
+          var newState = Object.assign({}, state);
+
+          for (var _key6 in update.updates) {
+            var _update$updates$_key, _update$updates$_key2;
+
+            if (((_update$updates$_key = update.updates[_key6]) == null ? void 0 : _update$updates$_key.type) === "update") {
+              var val = update.node.get(_key6);
+
+              if (val !== undefined) {
+                newState[_key6] = lsonToJson(val);
+              }
+            } else if (((_update$updates$_key2 = update.updates[_key6]) == null ? void 0 : _update$updates$_key2.type) === "delete") {
+              delete newState[_key6];
+            }
+          }
+
+          return newState;
+        }
+
+      case "LiveList":
+        {
+          if (Array.isArray(state) === false) {
+            throw new Error("Internal: received update on LiveList but state was not an array");
+          }
+
+          var _newState = state.map(function (x) {
+            return x;
+          });
+
+          var _loop = function _loop() {
+            var listUpdate = _step2.value;
+
+            if (listUpdate.type === "set") {
+              _newState = _newState.map(function (item, index) {
+                return index === listUpdate.index ? listUpdate.item : item;
+              });
+            } else if (listUpdate.type === "insert") {
+              if (listUpdate.index === _newState.length) {
+                _newState.push(lsonToJson(listUpdate.item));
+              } else {
+                _newState = [].concat(_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 = [].concat(_newState.slice(0, listUpdate.index), [lsonToJson(listUpdate.item)], _newState.slice(listUpdate.index, listUpdate.previousIndex), _newState.slice(listUpdate.previousIndex + 1));
+              } else {
+                _newState = [].concat(_newState.slice(0, listUpdate.previousIndex), _newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1), [lsonToJson(listUpdate.item)], _newState.slice(listUpdate.index + 1));
+              }
+            }
+          };
+
+          for (var _iterator2 = LiveObject._createForOfIteratorHelperLoose(update.updates), _step2; !(_step2 = _iterator2()).done;) {
+            _loop();
+          }
+
+          return _newState;
+        }
+
+      case "LiveMap":
+        {
+          if (typeof state !== "object") {
+            throw new Error("Internal: received update on LiveMap but state was not an object");
+          }
+
+          var _newState2 = Object.assign({}, state);
+
+          for (var _key7 in update.updates) {
+            var _update$updates$_key3, _update$updates$_key4;
+
+            if (((_update$updates$_key3 = update.updates[_key7]) == null ? void 0 : _update$updates$_key3.type) === "update") {
+              _newState2[_key7] = lsonToJson(update.node.get(_key7));
+            } else if (((_update$updates$_key4 = update.updates[_key7]) == null ? void 0 : _update$updates$_key4.type) === "delete") {
+              delete _newState2[_key7];
+            }
+          }
+
+          return _newState2;
+        }
+    }
+  }
+
+  if (Array.isArray(state)) {
+    var newArray = [].concat(state);
+    newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+    return newArray;
+  } else {
+    var _extends2;
+
+    return LiveObject._extends({}, state, (_extends2 = {}, _extends2[pathItem] = patchImmutableNode(state[pathItem], path, update), _extends2));
+  }
+}
+
+var internals = {
+  liveObjectToJson: liveObjectToJson,
+  lsonToJson: lsonToJson,
+  patchLiveList: patchLiveList,
+  patchImmutableObject: patchImmutableObject,
+  patchLiveObject: patchLiveObject,
+  patchLiveObjectKey: patchLiveObjectKey
+};
+
+exports.LiveList = LiveObject.LiveList;
+exports.LiveMap = LiveObject.LiveMap;
+exports.LiveObject = LiveObject.LiveObject;
+exports.createClient = createClient;
+exports.internals = internals;