@liveblocks/client 0.17.8 → 0.17.9

package/internal.js

@@ -1,331 +1,548 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: !0 });
-var Json = require("./shared.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _optionalChain(ops) {
+    var lastAccessLHS = undefined;
+    var value = ops[0];
+    var i = 1;
+    while(i < ops.length){
+        var op = ops[i];
+        var fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+            return undefined;
+        }
+        if (op === "access" || op === "optionalAccess") {
+            lastAccessLHS = value;
+            value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+            var _value;
+            value = fn(function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return (_value = value).call.apply(_value, [
+                    lastAccessLHS
+                ].concat(_toConsumableArray(args)));
+            });
+            lastAccessLHS = undefined;
+        }
+    }
+    return value;
+}
+var _chunkQLMVHHAZjs = require("./chunk-QLMVHHAZ.js");
+// src/immutable.ts
 function lsonObjectToJson(obj) {
-  var result = {};
-  for (var key in obj) {
-    var val = obj[key];
-    void 0 !== val && (result[key] = lsonToJson(val));
-  }
-  return result;
+    var result = {};
+    for(var key in obj){
+        var val = obj[key];
+        if (val !== void 0) {
+            result[key] = lsonToJson(val);
+        }
+    }
+    return result;
+}
+function liveObjectToJson(liveObject) {
+    return lsonObjectToJson(liveObject.toObject());
+}
+function liveMapToJson(map) {
+    var result = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = map.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+            result[key] = lsonToJson(value);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
 }
 function lsonListToJson(value) {
-  return value.map(lsonToJson);
+    return value.map(lsonToJson);
+}
+function liveListToJson(value) {
+    return lsonListToJson(value.toArray());
 }
 function lsonToJson(value) {
-  return value instanceof Json.LiveObject
-    ? lsonObjectToJson(value.toObject())
-    : value instanceof Json.LiveList
-    ? (function (value) {
-        return lsonListToJson(value.toArray());
-      })(value)
-    : value instanceof Json.LiveMap
-    ? (function (map) {
-        for (
-          var _step,
-            result = {},
-            _iterator = Json._createForOfIteratorHelperLoose(map.entries());
-          !(_step = _iterator()).done;
-
-        ) {
-          var _step$value = _step.value,
-            key = _step$value[0],
-            value = _step$value[1];
-          result[key] = lsonToJson(value);
-        }
-        return result;
-      })(value)
-    : value instanceof Json.LiveRegister
-    ? value.data
-    : Array.isArray(value)
-    ? lsonListToJson(value)
-    : Json.isPlainObject(value)
-    ? lsonObjectToJson(value)
-    : value;
+    if (_instanceof(value, _chunkQLMVHHAZjs.LiveObject)) {
+        return liveObjectToJson(value);
+    } else if (_instanceof(value, _chunkQLMVHHAZjs.LiveList)) {
+        return liveListToJson(value);
+    } else if (_instanceof(value, _chunkQLMVHHAZjs.LiveMap)) {
+        return liveMapToJson(value);
+    } else if (_instanceof(value, _chunkQLMVHHAZjs.LiveRegister)) {
+        return value.data;
+    }
+    if (Array.isArray(value)) {
+        return lsonListToJson(value);
+    } else if (_chunkQLMVHHAZjs.isPlainObject.call(void 0, value)) {
+        return lsonObjectToJson(value);
+    }
+    return value;
 }
 function deepLiveify(value) {
-  if (Array.isArray(value)) return new Json.LiveList(value.map(deepLiveify));
-  if (Json.isPlainObject(value)) {
-    var init = {};
-    for (var key in value) {
-      var val = value[key];
-      void 0 !== val && (init[key] = deepLiveify(val));
+    if (Array.isArray(value)) {
+        return new (0, _chunkQLMVHHAZjs.LiveList)(value.map(deepLiveify));
+    } else if (_chunkQLMVHHAZjs.isPlainObject.call(void 0, value)) {
+        var init = {};
+        for(var key in value){
+            var val = value[key];
+            if (val === void 0) {
+                continue;
+            }
+            init[key] = deepLiveify(val);
+        }
+        return new (0, _chunkQLMVHHAZjs.LiveObject)(init);
+    } else {
+        return value;
     }
-    return new Json.LiveObject(init);
-  }
-  return value;
 }
-function patchLiveObjectKey(liveObject, key, prev, next) {
-  if ("production" !== process.env.NODE_ENV) {
-    var nonSerializableValue = Json.findNonSerializableValue(next);
-    if (nonSerializableValue)
-      return void console.error(
-        "New state path: '" +
-          nonSerializableValue.path +
-          "' value: '" +
-          nonSerializableValue.value +
-          "' is not serializable.\nOnly serializable value can be synced with Liveblocks."
-      );
-  }
-  var value = liveObject.get(key);
-  if (void 0 === next) liveObject.delete(key);
-  else if (void 0 === value) liveObject.set(key, deepLiveify(next));
-  else {
-    if (prev === next) return;
-    Json.isLiveList(value) && Array.isArray(prev) && Array.isArray(next)
-      ? (function (liveList, prev, next) {
-          var i = 0,
-            prevEnd = prev.length - 1,
-            nextEnd = next.length - 1,
-            prevNode = prev[0],
-            nextNode = next[0];
-          outer: {
-            for (; prevNode === nextNode; ) {
-              if (++i > prevEnd || i > nextEnd) break outer;
-              (prevNode = prev[i]), (nextNode = next[i]);
+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;
             }
-            for (
-              prevNode = prev[prevEnd], nextNode = next[nextEnd];
-              prevNode === nextNode;
-
-            ) {
-              if ((nextEnd--, i > --prevEnd || i > nextEnd)) break outer;
-              (prevNode = prev[prevEnd]), (nextNode = next[nextEnd]);
+            prevNode = prev[i];
+            nextNode = next[i];
+        }
+        prevNode = prev[prevEnd];
+        nextNode = next[nextEnd];
+        while(prevNode === nextNode){
+            prevEnd--;
+            nextEnd--;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
             }
-          }
-          if (i > prevEnd) {
-            if (i <= nextEnd)
-              for (; i <= nextEnd; )
-                liveList.insert(deepLiveify(next[i]), i), i++;
-          } else if (i > nextEnd)
-            for (var localI = i; localI <= prevEnd; )
-              liveList.delete(i), localI++;
-          else {
-            for (; i <= prevEnd && i <= nextEnd; ) {
-              (prevNode = prev[i]), (nextNode = next[i]);
-              var liveListNode = liveList.get(i);
-              Json.isLiveObject(liveListNode) &&
-              Json.isPlainObject(prevNode) &&
-              Json.isPlainObject(nextNode)
-                ? patchLiveObject(liveListNode, prevNode, nextNode)
-                : liveList.set(i, deepLiveify(nextNode)),
+            prevNode = prev[prevEnd];
+            nextNode = next[nextEnd];
+        }
+    }
+    if (i > prevEnd) {
+        if (i <= nextEnd) {
+            while(i <= nextEnd){
+                liveList.insert(deepLiveify(next[i]), i);
                 i++;
             }
-            for (; i <= nextEnd; )
-              liveList.insert(deepLiveify(next[i]), i), i++;
-            for (var _localI = i; _localI <= prevEnd; )
-              liveList.delete(i), _localI++;
-          }
-        })(value, prev, next)
-      : Json.isLiveObject(value) &&
-        Json.isPlainObject(prev) &&
-        Json.isPlainObject(next)
-      ? patchLiveObject(value, prev, next)
-      : liveObject.set(key, deepLiveify(next));
-  }
+        }
+    } 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 (_chunkQLMVHHAZjs.isLiveObject.call(void 0, liveListNode) && _chunkQLMVHHAZjs.isPlainObject.call(void 0, prevNode) && _chunkQLMVHHAZjs.isPlainObject.call(void 0, nextNode)) {
+                patchLiveObject(liveListNode, prevNode, nextNode);
+            } else {
+                liveList.set(i, deepLiveify(nextNode));
+            }
+            i++;
+        }
+        while(i <= nextEnd){
+            liveList.insert(deepLiveify(next[i]), i);
+            i++;
+        }
+        var localI1 = i;
+        while(localI1 <= prevEnd){
+            liveList.delete(i);
+            localI1++;
+        }
+    }
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+    if (process.env.NODE_ENV !== "production") {
+        var nonSerializableValue = _chunkQLMVHHAZjs.findNonSerializableValue.call(void 0, next);
+        if (nonSerializableValue) {
+            console.error("New state path: '".concat(nonSerializableValue.path, "' value: '").concat(nonSerializableValue.value, "' is not serializable.\nOnly serializable value can be synced with Liveblocks."));
+            return;
+        }
+    }
+    var 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 (_chunkQLMVHHAZjs.isLiveList.call(void 0, value) && Array.isArray(prev) && Array.isArray(next)) {
+        patchLiveList(value, prev, next);
+    } else if (_chunkQLMVHHAZjs.isLiveObject.call(void 0, value) && _chunkQLMVHHAZjs.isPlainObject.call(void 0, prev) && _chunkQLMVHHAZjs.isPlainObject.call(void 0, next)) {
+        patchLiveObject(value, prev, next);
+    } else {
+        liveObject.set(key, deepLiveify(next));
+    }
 }
 function patchLiveObject(root, prev, next) {
-  var updates = {};
-  for (var key in next) patchLiveObjectKey(root, key, prev[key], next[key]);
-  for (var _key in prev) void 0 === next[_key] && root.delete(_key);
-  Object.keys(updates).length > 0 && root.update(updates);
+    var updates = {};
+    for(var key in next){
+        patchLiveObjectKey(root, key, prev[key], next[key]);
+    }
+    for(var key1 in prev){
+        if (next[key1] === void 0) {
+            root.delete(key1);
+        }
+    }
+    if (Object.keys(updates).length > 0) {
+        root.update(updates);
+    }
+}
+function getParentsPath(node) {
+    var path = [];
+    while(node.parent.type === "HasParent"){
+        if (_chunkQLMVHHAZjs.isLiveList.call(void 0, 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 patchImmutableObject(state, updates) {
+    return updates.reduce(function(state2, update) {
+        return patchImmutableObjectWithUpdate(state2, 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 (void 0 === pathItem)
-    switch (update.type) {
-      case "LiveObject":
-        if (null === state || "object" != typeof state || Array.isArray(state))
-          throw new Error(
-            "Internal: received update on LiveObject but state was not an object"
-          );
-        var newState = Object.assign({}, state);
-        for (var key in update.updates) {
-          var _update$updates$key, _update$updates$key2;
-          if (
-            "update" ===
-            (null == (_update$updates$key = update.updates[key])
-              ? void 0
-              : _update$updates$key.type)
-          ) {
-            var val = update.node.get(key);
-            void 0 !== val && (newState[key] = lsonToJson(val));
-          } else
-            "delete" ===
-              (null == (_update$updates$key2 = update.updates[key])
-                ? void 0
-                : _update$updates$key2.type) && delete newState[key];
+    var pathItem = path.pop();
+    if (pathItem === void 0) {
+        switch(update.type){
+            case "LiveObject":
+                {
+                    var _loop = function(key) {
+                        if (_optionalChain([
+                            update,
+                            "access",
+                            function(_) {
+                                return _.updates;
+                            },
+                            "access",
+                            function(_2) {
+                                return _2[key];
+                            },
+                            "optionalAccess",
+                            function(_3) {
+                                return _3.type;
+                            }
+                        ]) === "update") {
+                            var val = update.node.get(key);
+                            if (val !== void 0) {
+                                newState[key] = lsonToJson(val);
+                            }
+                        } else if (_optionalChain([
+                            update,
+                            "access",
+                            function(_4) {
+                                return _4.updates;
+                            },
+                            "access",
+                            function(_5) {
+                                return _5[key];
+                            },
+                            "optionalAccess",
+                            function(_6) {
+                                return _6.type;
+                            }
+                        ]) === "delete") {
+                            delete newState[key];
+                        }
+                    };
+                    if (state === null || typeof state !== "object" || Array.isArray(state)) {
+                        throw new Error("Internal: received update on LiveObject but state was not an object");
+                    }
+                    var newState = Object.assign({}, state);
+                    for(var key in update.updates)_loop(key);
+                    return newState;
+                }
+            case "LiveList":
+                {
+                    if (!Array.isArray(state)) {
+                        throw new Error("Internal: received update on LiveList but state was not an array");
+                    }
+                    var newState1 = state.map(function(x) {
+                        return x;
+                    });
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        var _loop1 = function() {
+                            var listUpdate = _step.value;
+                            if (listUpdate.type === "set") {
+                                newState1 = newState1.map(function(item, index) {
+                                    return index === listUpdate.index ? lsonToJson(listUpdate.item) : item;
+                                });
+                            } else if (listUpdate.type === "insert") {
+                                if (listUpdate.index === newState1.length) {
+                                    newState1.push(lsonToJson(listUpdate.item));
+                                } else {
+                                    newState1 = _toConsumableArray(newState1.slice(0, listUpdate.index)).concat([
+                                        lsonToJson(listUpdate.item)
+                                    ], _toConsumableArray(newState1.slice(listUpdate.index)));
+                                }
+                            } else if (listUpdate.type === "delete") {
+                                newState1.splice(listUpdate.index, 1);
+                            } else if (listUpdate.type === "move") {
+                                if (listUpdate.previousIndex > listUpdate.index) {
+                                    newState1 = _toConsumableArray(newState1.slice(0, listUpdate.index)).concat([
+                                        lsonToJson(listUpdate.item)
+                                    ], _toConsumableArray(newState1.slice(listUpdate.index, listUpdate.previousIndex)), _toConsumableArray(newState1.slice(listUpdate.previousIndex + 1)));
+                                } else {
+                                    newState1 = _toConsumableArray(newState1.slice(0, listUpdate.previousIndex)).concat(_toConsumableArray(newState1.slice(listUpdate.previousIndex + 1, listUpdate.index + 1)), [
+                                        lsonToJson(listUpdate.item)
+                                    ], _toConsumableArray(newState1.slice(listUpdate.index + 1)));
+                                }
+                            }
+                        };
+                        for(var _iterator = update.updates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop1();
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    return newState1;
+                }
+            case "LiveMap":
+                {
+                    var _loop2 = function(key1) {
+                        if (_optionalChain([
+                            update,
+                            "access",
+                            function(_7) {
+                                return _7.updates;
+                            },
+                            "access",
+                            function(_8) {
+                                return _8[key1];
+                            },
+                            "optionalAccess",
+                            function(_9) {
+                                return _9.type;
+                            }
+                        ]) === "update") {
+                            var value = update.node.get(key1);
+                            if (value !== void 0) {
+                                newState2[key1] = lsonToJson(value);
+                            }
+                        } else if (_optionalChain([
+                            update,
+                            "access",
+                            function(_10) {
+                                return _10.updates;
+                            },
+                            "access",
+                            function(_11) {
+                                return _11[key1];
+                            },
+                            "optionalAccess",
+                            function(_12) {
+                                return _12.type;
+                            }
+                        ]) === "delete") {
+                            delete newState2[key1];
+                        }
+                    };
+                    if (state === null || typeof state !== "object" || Array.isArray(state)) {
+                        throw new Error("Internal: received update on LiveMap but state was not an object");
+                    }
+                    var newState2 = Object.assign({}, state);
+                    for(var key1 in update.updates)_loop2(key1);
+                    return newState2;
+                }
         }
-        return newState;
-      case "LiveList":
-        if (!Array.isArray(state))
-          throw new Error(
-            "Internal: received update on LiveList but state was not an array"
-          );
-        for (
-          var _step2,
-            _newState = state.map(function (x) {
-              return x;
-            }),
-            _loop = function () {
-              var listUpdate = _step2.value;
-              "set" === listUpdate.type
-                ? (_newState = _newState.map(function (item, index) {
-                    return index === listUpdate.index
-                      ? lsonToJson(listUpdate.item)
-                      : item;
-                  }))
-                : "insert" === listUpdate.type
-                ? listUpdate.index === _newState.length
-                  ? _newState.push(lsonToJson(listUpdate.item))
-                  : (_newState = [].concat(
-                      _newState.slice(0, listUpdate.index),
-                      [lsonToJson(listUpdate.item)],
-                      _newState.slice(listUpdate.index)
-                    ))
-                : "delete" === listUpdate.type
-                ? _newState.splice(listUpdate.index, 1)
-                : "move" === listUpdate.type &&
-                  (_newState =
-                    listUpdate.previousIndex > listUpdate.index
-                      ? [].concat(
-                          _newState.slice(0, listUpdate.index),
-                          [lsonToJson(listUpdate.item)],
-                          _newState.slice(
-                            listUpdate.index,
-                            listUpdate.previousIndex
-                          ),
-                          _newState.slice(listUpdate.previousIndex + 1)
-                        )
-                      : [].concat(
-                          _newState.slice(0, listUpdate.previousIndex),
-                          _newState.slice(
-                            listUpdate.previousIndex + 1,
-                            listUpdate.index + 1
-                          ),
-                          [lsonToJson(listUpdate.item)],
-                          _newState.slice(listUpdate.index + 1)
-                        ));
-            },
-            _iterator2 = Json._createForOfIteratorHelperLoose(update.updates);
-          !(_step2 = _iterator2()).done;
-
-        )
-          _loop();
-        return _newState;
-      case "LiveMap":
-        if (null === state || "object" != typeof state || Array.isArray(state))
-          throw new Error(
-            "Internal: received update on LiveMap but state was not an object"
-          );
-        var _newState2 = Object.assign({}, state);
-        for (var _key2 in update.updates) {
-          var _update$updates$_key, _update$updates$_key2;
-          if (
-            "update" ===
-            (null == (_update$updates$_key = update.updates[_key2])
-              ? void 0
-              : _update$updates$_key.type)
-          ) {
-            var value = update.node.get(_key2);
-            void 0 !== value && (_newState2[_key2] = lsonToJson(value));
-          } else
-            "delete" ===
-              (null == (_update$updates$_key2 = update.updates[_key2])
-                ? void 0
-                : _update$updates$_key2.type) && delete _newState2[_key2];
+    }
+    if (Array.isArray(state)) {
+        var newArray = _toConsumableArray(state);
+        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+        return newArray;
+    } else if (state !== null && typeof state === "object") {
+        var node = state[pathItem];
+        if (node === void 0) {
+            return state;
+        } else {
+            return _objectSpreadProps(_objectSpread({}, state), _defineProperty({}, pathItem, patchImmutableNode(node, path, update)));
         }
-        return _newState2;
+    } else {
+        return state;
     }
-  if (Array.isArray(state)) {
-    var newArray = [].concat(state);
-    return (
-      (newArray[pathItem] = patchImmutableNode(state[pathItem], path, update)),
-      newArray
-    );
-  }
-  if (null !== state && "object" == typeof state) {
-    var _extends2,
-      node = state[pathItem];
-    return void 0 === node
-      ? state
-      : Json._extends(
-          {},
-          state,
-          (((_extends2 = {})[pathItem] = patchImmutableNode(
-            node,
-            path,
-            update
-          )),
-          _extends2)
-        );
-  }
-  return state;
 }
-Object.defineProperty(exports, "ClientMsgCode", {
-  enumerable: !0,
-  get: function () {
-    return Json.ClientMsgCode;
-  },
-}),
-  Object.defineProperty(exports, "CrdtType", {
-    enumerable: !0,
-    get: function () {
-      return Json.CrdtType;
-    },
-  }),
-  Object.defineProperty(exports, "OpCode", {
-    enumerable: !0,
-    get: function () {
-      return Json.OpCode;
-    },
-  }),
-  Object.defineProperty(exports, "ServerMsgCode", {
-    enumerable: !0,
-    get: function () {
-      return Json.ServerMsgCode;
-    },
-  }),
-  Object.defineProperty(exports, "WebsocketCloseCodes", {
-    enumerable: !0,
-    get: function () {
-      return Json.WebsocketCloseCodes;
-    },
-  }),
-  (exports.assertNever = Json.assertNever),
-  (exports.b64decode = Json.b64decode),
-  (exports.comparePosition = Json.comparePosition),
-  (exports.deprecate = Json.deprecate),
-  (exports.deprecateIf = Json.deprecateIf),
-  (exports.errorIf = Json.errorIf),
-  (exports.isAppOnlyAuthToken = Json.isAppOnlyAuthToken),
-  (exports.isAuthToken = Json.isAuthToken),
-  (exports.isChildCrdt = Json.isChildCrdt),
-  (exports.isJsonArray = Json.isJsonArray),
-  (exports.isJsonObject = Json.isJsonObject),
-  (exports.isJsonScalar = Json.isJsonScalar),
-  (exports.isPlainObject = Json.isPlainObject),
-  (exports.isRoomAuthToken = Json.isRoomAuthToken),
-  (exports.isRootCrdt = Json.isRootCrdt),
-  (exports.isScope = Json.isScope),
-  (exports.makePosition = Json.makePosition),
-  (exports.nn = Json.nn),
-  (exports.throwUsageError = Json.throwUsageError),
-  (exports.tryParseJson = Json.tryParseJson),
-  (exports.lsonToJson = lsonToJson),
-  (exports.patchImmutableObject = function (state, updates) {
-    return updates.reduce(function (state, update) {
-      return (function (state, update) {
-        var path = (function (node) {
-          for (var path = []; "HasParent" === node.parent.type; )
-            Json.isLiveList(node.parent.node)
-              ? path.push(node.parent.node._indexOfPosition(node.parent.key))
-              : path.push(node.parent.key),
-              (node = node.parent.node);
-          return path;
-        })(update.node);
-        return patchImmutableNode(state, path, update);
-      })(state, update);
-    }, state);
-  }),
-  (exports.patchLiveObjectKey = patchLiveObjectKey);
+exports.ClientMsgCode = _chunkQLMVHHAZjs.ClientMsgCode;
+exports.CrdtType = _chunkQLMVHHAZjs.CrdtType;
+exports.OpCode = _chunkQLMVHHAZjs.OpCode;
+exports.ServerMsgCode = _chunkQLMVHHAZjs.ServerMsgCode;
+exports.WebsocketCloseCodes = _chunkQLMVHHAZjs.WebsocketCloseCodes;
+exports.assertNever = _chunkQLMVHHAZjs.assertNever;
+exports.b64decode = _chunkQLMVHHAZjs.b64decode;
+exports.comparePosition = _chunkQLMVHHAZjs.comparePosition;
+exports.deprecate = _chunkQLMVHHAZjs.deprecate;
+exports.deprecateIf = _chunkQLMVHHAZjs.deprecateIf;
+exports.errorIf = _chunkQLMVHHAZjs.errorIf;
+exports.isAppOnlyAuthToken = _chunkQLMVHHAZjs.isAppOnlyAuthToken;
+exports.isAuthToken = _chunkQLMVHHAZjs.isAuthToken;
+exports.isChildCrdt = _chunkQLMVHHAZjs.isChildCrdt;
+exports.isJsonArray = _chunkQLMVHHAZjs.isJsonArray;
+exports.isJsonObject = _chunkQLMVHHAZjs.isJsonObject;
+exports.isJsonScalar = _chunkQLMVHHAZjs.isJsonScalar;
+exports.isPlainObject = _chunkQLMVHHAZjs.isPlainObject;
+exports.isRoomAuthToken = _chunkQLMVHHAZjs.isRoomAuthToken;
+exports.isRootCrdt = _chunkQLMVHHAZjs.isRootCrdt;
+exports.isScope = _chunkQLMVHHAZjs.isScope;
+exports.lsonToJson = lsonToJson;
+exports.makePosition = _chunkQLMVHHAZjs.makePosition;
+exports.nn = _chunkQLMVHHAZjs.nn;
+exports.patchImmutableObject = patchImmutableObject;
+exports.patchLiveObjectKey = patchLiveObjectKey;
+exports.throwUsageError = _chunkQLMVHHAZjs.throwUsageError;
+exports.tryParseJson = _chunkQLMVHHAZjs.tryParseJson;