@textbus/collaborate 5.2.3 → 5.2.4

package/dist/index.esm.js

@@ -1,1416 +1,2437 @@
-import { Injectable, Inject, Optional } from "@viewfly/core";
-import { makeError, HISTORY_STACK_SIZE, ChangeOrigin, Slot, observe, AsyncSlot, AsyncComponent, Component, History, Selection } from "@textbus/core";
-import { Subject, map, filter, Subscription } from "@tanbo/stream";
-import { UndoManager, Doc, createAbsolutePositionFromRelativePosition, createRelativePositionFromTypeIndex, Map, Array as Array$1, Text } from "yjs";
-import { HocuspocusProvider } from "@hocuspocus/provider";
-import { WebsocketProvider } from "y-websocket";
-var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
-var __decorateClass$3 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(result) || result;
-  return result;
-};
-var __decorateParam$1 = (index, decorator) => (target, key) => decorator(target, key, index);
-class CustomUndoManagerConfig {
-}
-const collabHistoryErrorFn = makeError("CollabHistory");
-let CollabHistory = class {
-  constructor(rootComponentRef, collaborate, scheduler, stackSize, undoManagerConfig) {
-    this.rootComponentRef = rootComponentRef;
-    this.collaborate = collaborate;
-    this.scheduler = scheduler;
-    this.stackSize = stackSize;
-    this.undoManagerConfig = undoManagerConfig;
-    this.onBack = this.backEvent.asObservable();
-    this.onForward = this.forwardEvent.asObservable();
-    this.onChange = this.changeEvent.asObservable();
-    this.onPush = this.pushEvent.asObservable();
-  }
-  rootComponentRef;
-  collaborate;
-  scheduler;
-  stackSize;
-  undoManagerConfig;
-  onBack;
-  onForward;
-  onChange;
-  onPush;
-  get canBack() {
-    return this.manager?.canUndo() || false;
-  }
-  get canForward() {
-    return this.manager?.canRedo() || false;
-  }
-  manager = null;
-  historyItems = [];
-  index = 0;
-  subscriptions = [];
-  backEvent = new Subject();
-  forwardEvent = new Subject();
-  changeEvent = new Subject();
-  pushEvent = new Subject();
-  listen() {
-    const root = this.collaborate.yDoc.getMap("RootComponent");
-    const rootComponent = this.rootComponentRef.component;
-    this.collaborate.syncRootComponent(this.collaborate.yDoc, root, rootComponent);
-    const undoManagerConfig = this.undoManagerConfig || {};
-    const manager = new UndoManager(root, {
-      trackedOrigins: /* @__PURE__ */ new Set([this.collaborate.yDoc]),
-      captureTransaction(arg) {
-        if (undoManagerConfig.captureTransaction) {
-          return undoManagerConfig.captureTransaction(arg);
-        }
-        return true;
-      },
-      deleteFilter(item) {
-        if (undoManagerConfig.deleteFilter) {
-          return undoManagerConfig.deleteFilter(item);
-        }
-        return true;
-      }
-    });
-    this.manager = manager;
-    let beforePosition = null;
-    this.subscriptions.push(
-      this.scheduler.onLocalChangeBefore.subscribe(() => {
-        beforePosition = this.collaborate.getRelativeCursorLocation();
-      }),
-      this.collaborate.onAddSubModel.subscribe(() => {
-        throw collabHistoryErrorFn("single document does not support submodels.");
-      })
-    );
-    manager.on("stack-item-added", (event) => {
-      if (event.type === "undo") {
-        if (event.origin === manager) {
-          this.index++;
-        } else {
-          this.historyItems.length = this.index;
-          this.historyItems.push({
-            before: beforePosition,
-            after: this.collaborate.getRelativeCursorLocation()
-          });
-          this.index++;
-        }
-      } else {
-        this.index--;
-      }
-      if (manager.undoStack.length > this.stackSize) {
-        this.historyItems.shift();
-        manager.undoStack.shift();
-      }
-      if (event.origin === this.collaborate.yDoc) {
-        this.pushEvent.next();
-      }
-      this.changeEvent.next();
-    });
-    manager.on("stack-item-popped", (ev) => {
-      const index = ev.type === "undo" ? this.index : this.index - 1;
-      const position = this.historyItems[index] || null;
-      const p = ev.type === "undo" ? position?.before : position?.after;
-      this.collaborate.restoreCursorPosition(p);
-    });
-  }
-  back() {
-    if (this.canBack) {
-      this.manager?.undo();
-      this.backEvent.next();
-    }
-  }
-  forward() {
-    if (this.canForward) {
-      this.manager?.redo();
-      this.forwardEvent.next();
-    }
-  }
-  clear() {
-    const last = this.historyItems.pop();
-    this.historyItems = last ? [last] : [];
-    this.index = last ? 1 : 0;
-    this.manager?.clear();
-    this.changeEvent.next();
-  }
-  destroy() {
-    this.index = 0;
-    this.historyItems = [];
-    this.subscriptions.forEach((i) => i.unsubscribe());
-    if (this.manager) {
-      this.manager.destroy();
-      this.manager.captureTransaction = () => true;
-      this.manager.deleteFilter = () => true;
-      this.manager.trackedOrigins = /* @__PURE__ */ new Set([null]);
+import { Injectable, Inject, Optional } from '@viewfly/core';
+import { makeError, Slot, ChangeOrigin, observe, AsyncSlot, AsyncComponent, Component, Scheduler, Registry, Selection, HISTORY_STACK_SIZE, RootComponentRef, History } from '@textbus/core';
+import { Subject, map, filter, Subscription } from '@tanbo/stream';
+import { Doc, createAbsolutePositionFromRelativePosition, createRelativePositionFromTypeIndex, Map, Array as Array$1, Text, UndoManager } from 'yjs';
+import { HocuspocusProvider } from '@hocuspocus/provider';
+import { WebsocketProvider } from 'y-websocket';
+
+function _assert_this_initialized$2(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
-    this.manager = null;
-  }
-};
-CollabHistory = __decorateClass$3([
-  Injectable(),
-  __decorateParam$1(3, Inject(HISTORY_STACK_SIZE)),
-  __decorateParam$1(4, Optional())
-], CollabHistory);
-var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
-var __decorateClass$2 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(result) || result;
-  return result;
-};
-const collaborateErrorFn = makeError("Collaborate");
-class SlotMap {
-  slotAndYTextMap = /* @__PURE__ */ new WeakMap();
-  yTextAndSlotMap = /* @__PURE__ */ new WeakMap();
-  set(key, value) {
-    if (key instanceof Slot) {
-      this.slotAndYTextMap.set(key, value);
-      this.yTextAndSlotMap.set(value, key);
-    } else {
-      this.slotAndYTextMap.set(value, key);
-      this.yTextAndSlotMap.set(key, value);
+    return self;
+}
+function _call_super$2(_this, derived, args) {
+    derived = _get_prototype_of$2(derived);
+    return _possible_constructor_return$2(_this, _is_native_reflect_construct$2() ? Reflect.construct(derived, args || [], _get_prototype_of$2(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$9(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-  }
-  get(key) {
-    if (key instanceof Slot) {
-      return this.slotAndYTextMap.get(key) || null;
+}
+function _defineProperties$8(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    return this.yTextAndSlotMap.get(key) || null;
-  }
-  delete(key) {
-    if (key instanceof Slot) {
-      const v = this.slotAndYTextMap.get(key);
-      this.slotAndYTextMap.delete(key);
-      if (v) {
-        this.yTextAndSlotMap.delete(v);
-      }
-    } else {
-      const v = this.yTextAndSlotMap.get(key);
-      this.yTextAndSlotMap.delete(key);
-      if (v) {
-        this.slotAndYTextMap.delete(v);
-      }
+}
+function _create_class$8(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$8(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _get_prototype_of$2(o) {
+    _get_prototype_of$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$2(o);
+}
+function _inherits$2(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
     }
-  }
-}
-let Collaborate = class {
-  constructor(scheduler, registry, selection, subModelLoader) {
-    this.scheduler = scheduler;
-    this.registry = registry;
-    this.selection = selection;
-    this.subModelLoader = subModelLoader;
-    this.onAddSubModel = this.addSubModelEvent.asObservable();
-  }
-  scheduler;
-  registry;
-  selection;
-  subModelLoader;
-  yDoc = new Doc();
-  slotMap = new SlotMap();
-  onAddSubModel;
-  subscriptions = [];
-  updateFromRemote = false;
-  addSubModelEvent = new Subject();
-  updateRemoteActions = /* @__PURE__ */ new WeakMap();
-  noRecord = {};
-  syncRootComponent(yDoc, sharedComponent, localComponent) {
-    this.initSyncEvent(yDoc);
-    this.syncComponent(yDoc, sharedComponent, localComponent);
-  }
-  syncRootSlot(yDoc, sharedSlot, localSlot) {
-    if (sharedSlot.length) {
-      localSlot.retain(0);
-      localSlot.delete(localSlot.length);
-      localSlot.cleanAttributes();
-      localSlot.cleanFormats();
-      this.initLocalSlotBySharedSlot(sharedSlot, localSlot);
-    } else {
-      yDoc.transact(() => {
-        this.initSharedSlotByLocalSlot(sharedSlot, localSlot);
-      });
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$2(subClass, superClass);
+}
+function _possible_constructor_return$2(self, call) {
+    if (call && (_type_of$3(call) === "object" || typeof call === "function")) {
+        return call;
     }
-    this.initSyncEvent(yDoc);
-    this.syncSlot(sharedSlot, localSlot);
-  }
-  getAbstractSelection(position) {
-    const anchorPosition = createAbsolutePositionFromRelativePosition(position.anchor.position, position.anchor.doc);
-    const focusPosition = createAbsolutePositionFromRelativePosition(position.focus.position, position.focus.doc);
-    if (anchorPosition && focusPosition) {
-      const focusSlot = this.slotMap.get(focusPosition.type);
-      const anchorSlot = this.slotMap.get(anchorPosition.type);
-      if (focusSlot && anchorSlot) {
-        return {
-          anchorSlot,
-          anchorOffset: anchorPosition.index,
-          focusSlot,
-          focusOffset: focusPosition.index
-        };
-      }
+    return _assert_this_initialized$2(self);
+}
+function _set_prototype_of$2(o, p) {
+    _set_prototype_of$2 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$2(o, p);
+}
+function _type_of$3(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$2() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$2 = function() {
+        return !!result;
+    })();
+}
+function _ts_decorate$3(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var subModelLoaderErrorFn = makeError('subModelLoaderError');
+/**
+ * 子文档加载器
+ */ var SubModelLoader = function SubModelLoader() {
+    _class_call_check$9(this, SubModelLoader);
+};
+var NonSubModelLoader = /*#__PURE__*/ function(SubModelLoader) {
+    _inherits$2(NonSubModelLoader, SubModelLoader);
+    function NonSubModelLoader() {
+        _class_call_check$9(this, NonSubModelLoader);
+        return _call_super$2(this, NonSubModelLoader, arguments);
     }
-    return null;
-  }
-  getRelativeCursorLocation() {
-    const { anchorSlot, anchorOffset, focusSlot, focusOffset } = this.selection;
-    if (anchorSlot) {
-      const anchorYText = this.slotMap.get(anchorSlot);
-      if (anchorYText) {
-        const anchorPosition = createRelativePositionFromTypeIndex(anchorYText, anchorOffset);
-        if (focusSlot) {
-          const focusYText = this.slotMap.get(focusSlot);
-          if (focusYText) {
-            const focusPosition = createRelativePositionFromTypeIndex(focusYText, focusOffset);
-            return {
-              focus: {
-                doc: focusYText.doc,
-                position: focusPosition
-              },
-              anchor: {
-                doc: anchorYText.doc,
-                position: anchorPosition
-              }
-            };
-          }
+    _create_class$8(NonSubModelLoader, [
+        {
+            key: "createSubModelBySlot",
+            value: function createSubModelBySlot() {
+                throw subModelLoaderErrorFn('single document does not support async slot.');
+            }
+        },
+        {
+            key: "createSubModelByComponent",
+            value: function createSubModelByComponent() {
+                throw subModelLoaderErrorFn('single document does not support async component.');
+            }
+        },
+        {
+            key: "loadSubModelByComponent",
+            value: function loadSubModelByComponent() {
+                throw subModelLoaderErrorFn('single document does not support async component.');
+            }
+        },
+        {
+            key: "loadSubModelBySlot",
+            value: function loadSubModelBySlot() {
+                throw subModelLoaderErrorFn('single document does not support async slot.');
+            }
+        },
+        {
+            key: "getLoadedModelBySlot",
+            value: function getLoadedModelBySlot() {
+                throw subModelLoaderErrorFn('single document does not support async slot.');
+            }
+        },
+        {
+            key: "getLoadedModelByComponent",
+            value: function getLoadedModelByComponent() {
+                throw subModelLoaderErrorFn('single document does not support async component.');
+            }
         }
-      }
+    ]);
+    return NonSubModelLoader;
+}(SubModelLoader);
+NonSubModelLoader = _ts_decorate$3([
+    Injectable()
+], NonSubModelLoader);
+
+function _array_like_to_array(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 _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check$8(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    return null;
-  }
-  restoreCursorPosition(position) {
-    if (!position) {
-      this.selection.unSelect();
-      return;
+}
+function _defineProperties$7(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    const selection = this.getAbstractSelection(position);
-    if (selection) {
-      this.selection.setBaseAndExtent(
-        selection.anchorSlot,
-        selection.anchorOffset,
-        selection.focusSlot,
-        selection.focusOffset
-      );
+}
+function _create_class$7(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$7(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$8(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-  }
-  initSyncEvent(yDoc) {
-    this.subscriptions.push(
-      this.scheduler.onDocChanged.pipe(
-        map((item) => {
-          return item.filter((i) => {
-            return i.from !== ChangeOrigin.Remote;
-          });
-        }),
-        filter((item) => {
-          return item.length;
-        })
-      ).subscribe(() => {
-        const updates = [];
-        let update = null;
-        const updateRemoteActions = this.updateRemoteActions.get(yDoc) || [];
-        for (const item of updateRemoteActions) {
-          if (!update) {
-            update = {
-              record: item.record,
-              actions: []
-            };
-            updates.push(update);
-          }
-          if (update.record === item.record) {
-            update.actions.push(item.action);
-          } else {
-            update = {
-              record: item.record,
-              actions: [item.action]
-            };
-            updates.push(update);
-          }
+    return obj;
+}
+function _instanceof$1(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(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;
         }
-        this.updateRemoteActions.delete(yDoc);
-        for (const item of updates) {
-          yDoc.transact(() => {
-            item.actions.forEach((fn) => {
-              fn();
-            });
-          }, item.record ? yDoc : this.noRecord);
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
         }
-      })
-    );
-  }
-  syncComponent(yDoc, sharedComponent, localComponent) {
-    let state = sharedComponent.get("state");
-    if (!state) {
-      state = new Map();
-      this.syncLocalMapToSharedMap(localComponent.state, state);
-      yDoc.transact(() => {
-        sharedComponent.set("state", state);
-      });
-    } else {
-      Object.keys(localComponent.state).forEach((key) => {
-        Reflect.deleteProperty(localComponent.state, key);
-      });
-      this.syncSharedMapToLocalMap(state, localComponent.state);
     }
-  }
-  syncSlot(sharedSlot, localSlot) {
-    const syncRemote = (ev, tr) => {
-      this.runRemoteUpdate(tr, () => {
-        localSlot.retain(0);
-        ev.keysChanged.forEach((key) => {
-          const change = ev.keys.get(key);
-          if (!change) {
-            return;
-          }
-          const updateType = change.action;
-          if (updateType === "update" || updateType === "add") {
-            const attribute = this.registry.getAttribute(key);
-            if (attribute) {
-              localSlot.setAttribute(attribute, sharedSlot.getAttribute(key));
-            }
-          } else if (updateType === "delete") {
-            const attribute = this.registry.getAttribute(key);
-            if (attribute) {
-              localSlot.removeAttribute(attribute);
-            }
-          }
-        });
-        ev.delta.forEach((action) => {
-          if (Reflect.has(action, "retain")) {
-            if (action.attributes) {
-              const formats = remoteFormatsToLocal(this.registry, action.attributes);
-              if (formats.length) {
-                localSlot.retain(action.retain, formats);
-              }
-            }
-            localSlot.retain(localSlot.index + action.retain);
-          } else if (action.insert) {
-            const index = localSlot.index;
-            let length = 1;
-            if (typeof action.insert === "string") {
-              length = action.insert.length;
-              localSlot.insert(action.insert, remoteFormatsToLocal(this.registry, action.attributes));
-            } else {
-              const sharedComponent = action.insert;
-              const component = this.createLocalComponentBySharedComponent(sharedComponent);
-              localSlot.insert(component);
-            }
-            if (this.selection.isSelected && !(tr.origin instanceof UndoManager)) {
-              if (localSlot === this.selection.anchorSlot && this.selection.anchorOffset > index) {
-                this.selection.setAnchor(localSlot, this.selection.anchorOffset + length);
-              }
-              if (localSlot === this.selection.focusSlot && this.selection.focusOffset > index) {
-                this.selection.setFocus(localSlot, this.selection.focusOffset + length);
-              }
-            }
-          } else if (action.delete) {
-            const index = localSlot.index;
-            localSlot.delete(action.delete);
-            if (this.selection.isSelected && !(tr.origin instanceof UndoManager)) {
-              if (localSlot === this.selection.anchorSlot && this.selection.anchorOffset >= index) {
-                this.selection.setAnchor(localSlot, this.selection.startOffset - action.delete);
-              }
-              if (localSlot === this.selection.focusSlot && this.selection.focusOffset >= index) {
-                this.selection.setFocus(localSlot, this.selection.focusOffset - action.delete);
-              }
-            }
-          }
-        });
-      });
-    };
-    sharedSlot.observe(syncRemote);
-    const sub = localSlot.onContentChange.subscribe((actions) => {
-      this.runLocalUpdate(sharedSlot.doc, true, () => {
-        let offset = 0;
-        let length = 0;
-        for (const action of actions) {
-          if (action.type === "retain") {
-            const formats = action.formats;
-            if (formats) {
-              const keys = Object.keys(formats);
-              let length2 = keys.length;
-              keys.forEach((key) => {
-                const formatter = this.registry.getFormatter(key);
-                if (!formatter) {
-                  length2--;
-                  Reflect.deleteProperty(formats, key);
+    return _arr;
+}
+function _non_iterable_rest() {
+    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 _non_iterable_spread() {
+    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 _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(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 _array_like_to_array(o, minLen);
+}
+function _ts_decorate$2(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata$2(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var collaborateErrorFn = makeError('Collaborate');
+var SlotMap = /*#__PURE__*/ function() {
+    function SlotMap() {
+        _class_call_check$8(this, SlotMap);
+        _define_property$8(this, "slotAndYTextMap", new WeakMap());
+        _define_property$8(this, "yTextAndSlotMap", new WeakMap());
+    }
+    _create_class$7(SlotMap, [
+        {
+            key: "set",
+            value: function set(key, value) {
+                if (_instanceof$1(key, Slot)) {
+                    this.slotAndYTextMap.set(key, value);
+                    this.yTextAndSlotMap.set(value, key);
+                } else {
+                    this.slotAndYTextMap.set(value, key);
+                    this.yTextAndSlotMap.set(key, value);
                 }
-              });
-              if (length2) {
-                sharedSlot.format(offset, action.offset, formats);
-              }
-            } else {
-              offset = action.offset;
-            }
-          } else if (action.type === "contentInsert") {
-            const delta = sharedSlot.toDelta();
-            const isEmpty = delta.length === 1 && delta[0].insert === Slot.emptyPlaceholder;
-            if (typeof action.content === "string") {
-              length = action.content.length;
-              sharedSlot.insert(offset, action.content, action.formats || {});
-            } else {
-              length = 1;
-              const sharedComponent = this.createSharedComponentByLocalComponent(action.ref);
-              sharedSlot.insertEmbed(offset, sharedComponent, action.formats || {});
-            }
-            if (isEmpty && offset === 0) {
-              sharedSlot.delete(sharedSlot.length - 1, 1);
-            }
-            offset += length;
-          } else if (action.type === "delete") {
-            const delta = sharedSlot.toDelta();
-            if (sharedSlot.length) {
-              sharedSlot.delete(offset, action.count);
-            }
-            if (sharedSlot.length === 0) {
-              sharedSlot.insert(0, "\n", delta[0]?.attributes);
-            }
-          } else if (action.type === "attrSet") {
-            sharedSlot.setAttribute(action.name, action.value);
-          } else if (action.type === "attrDelete") {
-            sharedSlot.removeAttribute(action.name);
-          }
-        }
-      });
-    });
-    this.slotMap.set(localSlot, sharedSlot);
-    localSlot.__changeMarker__.addDetachCallback(() => {
-      this.slotMap.delete(localSlot);
-      sharedSlot.unobserve(syncRemote);
-      sub.unsubscribe();
-    });
-  }
-  destroy() {
-    this.subscriptions.forEach((i) => i.unsubscribe());
-    this.subscriptions = [];
-  }
-  syncSharedMapToLocalMap(sharedMap, localMap) {
-    sharedMap.forEach((value, key) => {
-      localMap[key] = this.createLocalModelBySharedByModel(value);
-    });
-    this.syncObject(sharedMap, localMap);
-  }
-  createLocalMapBySharedMap(sharedMap) {
-    const localMap = observe({});
-    this.syncSharedMapToLocalMap(sharedMap, localMap);
-    return localMap;
-  }
-  createLocalArrayBySharedArray(sharedArray) {
-    const localArray = observe([]);
-    localArray.push(...sharedArray.map((item) => this.createLocalModelBySharedByModel(item)));
-    this.syncArray(sharedArray, localArray);
-    return localArray;
-  }
-  syncLocalMapToSharedMap(localMap, sharedMap) {
-    Object.entries(localMap).forEach(([key, value]) => {
-      sharedMap.set(key, this.createSharedModelByLocalModel(value));
-    });
-    this.syncObject(sharedMap, localMap);
-  }
-  createSharedMapByLocalMap(localMap) {
-    const sharedMap = new Map();
-    this.syncLocalMapToSharedMap(localMap, sharedMap);
-    return sharedMap;
-  }
-  createSharedArrayByLocalArray(localArray) {
-    const sharedArray = new Array$1();
-    localArray.forEach((value) => {
-      sharedArray.push([this.createSharedModelByLocalModel(value)]);
-    });
-    this.syncArray(sharedArray, localArray);
-    return sharedArray;
-  }
-  createSharedSlotByLocalSlot(localSlot) {
-    const sharedSlot = new Text();
-    const isAsyncSlot = localSlot instanceof AsyncSlot;
-    sharedSlot.setAttribute("schema", [...localSlot.schema]);
-    sharedSlot.setAttribute("type", isAsyncSlot ? "async" : "sync");
-    if (isAsyncSlot) {
-      let isDestroyed = false;
-      const sharedMetadata = this.createSharedMapByLocalMap(localSlot.metadata);
-      sharedSlot.setAttribute("metadata", sharedMetadata);
-      this.subModelLoader.createSubModelBySlot(localSlot).then((subDocument) => {
-        if (isDestroyed) {
-          return;
+            }
+        },
+        {
+            key: "get",
+            value: function get(key) {
+                if (_instanceof$1(key, Slot)) {
+                    return this.slotAndYTextMap.get(key) || null;
+                }
+                return this.yTextAndSlotMap.get(key) || null;
+            }
+        },
+        {
+            key: "delete",
+            value: function _delete(key) {
+                if (_instanceof$1(key, Slot)) {
+                    var v = this.slotAndYTextMap.get(key);
+                    this.slotAndYTextMap.delete(key);
+                    if (v) {
+                        this.yTextAndSlotMap.delete(v);
+                    }
+                } else {
+                    var v1 = this.yTextAndSlotMap.get(key);
+                    this.yTextAndSlotMap.delete(key);
+                    if (v1) {
+                        this.slotAndYTextMap.delete(v1);
+                    }
+                }
+            }
         }
-        const content = subDocument.getText("content");
-        const state = subDocument.getMap("state");
-        this.syncLocalMapToSharedMap(localSlot.state, state);
-        this.initSharedSlotByLocalSlot(content, localSlot);
-        this.syncSlot(content, localSlot);
-        this.addSubModelEvent.next({
-          yDoc: subDocument,
-          yType: content
-        });
-        this.initSyncEvent(subDocument);
-        localSlot.loader.markAsLoaded();
-      });
-      localSlot.__changeMarker__.addDetachCallback(() => {
-        isDestroyed = true;
-      });
-      return sharedSlot;
+    ]);
+    return SlotMap;
+}();
+var Collaborate = /*#__PURE__*/ function() {
+    function Collaborate(scheduler, registry, selection, subModelLoader) {
+        _class_call_check$8(this, Collaborate);
+        _define_property$8(this, "scheduler", void 0);
+        _define_property$8(this, "registry", void 0);
+        _define_property$8(this, "selection", void 0);
+        _define_property$8(this, "subModelLoader", void 0);
+        _define_property$8(this, "yDoc", void 0);
+        _define_property$8(this, "slotMap", void 0);
+        _define_property$8(this, "onAddSubModel", void 0);
+        _define_property$8(this, "subscriptions", void 0);
+        _define_property$8(this, "updateFromRemote", void 0);
+        _define_property$8(this, "addSubModelEvent", void 0);
+        _define_property$8(this, "updateRemoteActions", void 0);
+        _define_property$8(this, "noRecord", void 0);
+        this.scheduler = scheduler;
+        this.registry = registry;
+        this.selection = selection;
+        this.subModelLoader = subModelLoader;
+        this.yDoc = new Doc();
+        this.slotMap = new SlotMap();
+        this.subscriptions = [];
+        this.updateFromRemote = false;
+        this.addSubModelEvent = new Subject();
+        this.updateRemoteActions = new WeakMap();
+        this.noRecord = {};
+        this.onAddSubModel = this.addSubModelEvent.asObservable();
     }
-    const sharedSlotState = new Map();
-    this.syncLocalMapToSharedMap(localSlot.state, sharedSlotState);
-    sharedSlot.setAttribute("state", sharedSlotState);
-    const sharedContent = new Text();
-    this.initSharedSlotByLocalSlot(sharedContent, localSlot);
-    sharedSlot.insertEmbed(0, sharedContent);
-    this.syncSlot(sharedContent, localSlot);
-    return sharedSlot;
-  }
-  initSharedSlotByLocalSlot(sharedContent, localSlot) {
-    let offset = 0;
-    localSlot.toDelta().forEach((i) => {
-      let formats = {};
-      if (i.formats) {
-        i.formats.forEach((item) => {
-          formats[item[0].name] = item[1];
-        });
-      } else {
-        formats = null;
-      }
-      if (typeof i.insert === "string") {
-        sharedContent.insert(offset, i.insert, formats);
-      } else {
-        const sharedComponent = this.createSharedComponentByLocalComponent(i.insert);
-        sharedContent.insertEmbed(offset, sharedComponent, formats);
-      }
-      offset += i.insert.length;
-    });
-    localSlot.getAttributes().forEach((item) => {
-      sharedContent.setAttribute(item[0].name, item[1]);
-    });
-  }
-  createLocalSlotBySharedSlot(sharedSlot) {
-    const type = sharedSlot.getAttribute("type");
-    const schema = sharedSlot.getAttribute("schema");
-    if (type === "async") {
-      const metadata = sharedSlot.getAttribute("metadata");
-      const slot = new AsyncSlot(schema || [], {}, {});
-      this.syncSharedMapToLocalMap(metadata, slot.metadata);
-      const loadedSubDocument = this.subModelLoader.getLoadedModelBySlot(slot);
-      if (loadedSubDocument) {
-        const subContent = loadedSubDocument.getText("content");
-        const data = loadedSubDocument.getMap("state");
-        this.syncSharedMapToLocalMap(data, slot.state);
-        this.syncRootSlot(loadedSubDocument, subContent, slot);
-        this.addSubModelEvent.next({
-          yDoc: loadedSubDocument,
-          yType: subContent
-        });
-        slot.loader.markAsLoaded();
-        return slot;
-      }
-      let isDestroyed = false;
-      slot.loader.onRequestLoad.toPromise().then(() => {
-        return this.subModelLoader.loadSubModelBySlot(slot);
-      }).then((subDocument) => {
-        if (isDestroyed) {
-          return;
+    _create_class$7(Collaborate, [
+        {
+            key: "syncRootComponent",
+            value: function syncRootComponent(yDoc, sharedComponent, localComponent) {
+                this.initSyncEvent(yDoc);
+                this.syncComponent(yDoc, sharedComponent, localComponent);
+            }
+        },
+        {
+            key: "syncRootSlot",
+            value: function syncRootSlot(yDoc, sharedSlot, localSlot) {
+                var _this = this;
+                if (sharedSlot.length) {
+                    localSlot.retain(0);
+                    localSlot.delete(localSlot.length);
+                    localSlot.cleanAttributes();
+                    localSlot.cleanFormats();
+                    this.initLocalSlotBySharedSlot(sharedSlot, localSlot);
+                } else {
+                    yDoc.transact(function() {
+                        _this.initSharedSlotByLocalSlot(sharedSlot, localSlot);
+                    });
+                }
+                this.initSyncEvent(yDoc);
+                this.syncSlot(sharedSlot, localSlot);
+            }
+        },
+        {
+            key: "getAbstractSelection",
+            value: function getAbstractSelection(position) {
+                var anchorPosition = createAbsolutePositionFromRelativePosition(position.anchor.position, position.anchor.doc);
+                var focusPosition = createAbsolutePositionFromRelativePosition(position.focus.position, position.focus.doc);
+                if (anchorPosition && focusPosition) {
+                    var focusSlot = this.slotMap.get(focusPosition.type);
+                    var anchorSlot = this.slotMap.get(anchorPosition.type);
+                    if (focusSlot && anchorSlot) {
+                        return {
+                            anchorSlot: anchorSlot,
+                            anchorOffset: anchorPosition.index,
+                            focusSlot: focusSlot,
+                            focusOffset: focusPosition.index
+                        };
+                    }
+                }
+                return null;
+            }
+        },
+        {
+            key: "getRelativeCursorLocation",
+            value: function getRelativeCursorLocation() {
+                var _this_selection = this.selection, anchorSlot = _this_selection.anchorSlot, anchorOffset = _this_selection.anchorOffset, focusSlot = _this_selection.focusSlot, focusOffset = _this_selection.focusOffset;
+                if (anchorSlot) {
+                    var anchorYText = this.slotMap.get(anchorSlot);
+                    if (anchorYText) {
+                        var anchorPosition = createRelativePositionFromTypeIndex(anchorYText, anchorOffset);
+                        if (focusSlot) {
+                            var focusYText = this.slotMap.get(focusSlot);
+                            if (focusYText) {
+                                var focusPosition = createRelativePositionFromTypeIndex(focusYText, focusOffset);
+                                return {
+                                    focus: {
+                                        doc: focusYText.doc,
+                                        position: focusPosition
+                                    },
+                                    anchor: {
+                                        doc: anchorYText.doc,
+                                        position: anchorPosition
+                                    }
+                                };
+                            }
+                        }
+                    }
+                }
+                return null;
+            }
+        },
+        {
+            key: "restoreCursorPosition",
+            value: function restoreCursorPosition(position) {
+                if (!position) {
+                    this.selection.unSelect();
+                    return;
+                }
+                var selection = this.getAbstractSelection(position);
+                if (selection) {
+                    this.selection.setBaseAndExtent(selection.anchorSlot, selection.anchorOffset, selection.focusSlot, selection.focusOffset);
+                }
+            }
+        },
+        {
+            key: "initSyncEvent",
+            value: function initSyncEvent(yDoc) {
+                var _this = this;
+                this.subscriptions.push(this.scheduler.onDocChanged.pipe(map(function(item) {
+                    return item.filter(function(i) {
+                        return i.from !== ChangeOrigin.Remote;
+                    });
+                }), filter(function(item) {
+                    return item.length;
+                })).subscribe(function() {
+                    var updates = [];
+                    var update = null;
+                    var updateRemoteActions = _this.updateRemoteActions.get(yDoc) || [];
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = updateRemoteActions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var item = _step.value;
+                            if (!update) {
+                                update = {
+                                    record: item.record,
+                                    actions: []
+                                };
+                                updates.push(update);
+                            }
+                            if (update.record === item.record) {
+                                update.actions.push(item.action);
+                            } else {
+                                update = {
+                                    record: item.record,
+                                    actions: [
+                                        item.action
+                                    ]
+                                };
+                                updates.push(update);
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    _this.updateRemoteActions.delete(yDoc);
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        var _loop = function() {
+                            var item = _step1.value;
+                            yDoc.transact(function() {
+                                item.actions.forEach(function(fn) {
+                                    fn();
+                                });
+                            }, item.record ? yDoc : _this.noRecord);
+                        };
+                        for(var _iterator1 = updates[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true)_loop();
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }));
+            }
+        },
+        {
+            key: "syncComponent",
+            value: function syncComponent(yDoc, sharedComponent, localComponent) {
+                var state = sharedComponent.get('state');
+                if (!state) {
+                    state = new Map();
+                    this.syncLocalMapToSharedMap(localComponent.state, state);
+                    yDoc.transact(function() {
+                        sharedComponent.set('state', state);
+                    });
+                } else {
+                    Object.keys(localComponent.state).forEach(function(key) {
+                        Reflect.deleteProperty(localComponent.state, key);
+                    });
+                    this.syncSharedMapToLocalMap(state, localComponent.state);
+                }
+            }
+        },
+        {
+            key: "syncSlot",
+            value: function syncSlot(sharedSlot, localSlot) {
+                var _this = this;
+                var syncRemote = function syncRemote(ev, tr) {
+                    _this.runRemoteUpdate(tr, function() {
+                        localSlot.retain(0);
+                        ev.keysChanged.forEach(function(key) {
+                            var change = ev.keys.get(key);
+                            if (!change) {
+                                return;
+                            }
+                            var updateType = change.action;
+                            if (updateType === 'update' || updateType === 'add') {
+                                var attribute = _this.registry.getAttribute(key);
+                                if (attribute) {
+                                    localSlot.setAttribute(attribute, sharedSlot.getAttribute(key));
+                                }
+                            } else if (updateType === 'delete') {
+                                var attribute1 = _this.registry.getAttribute(key);
+                                if (attribute1) {
+                                    localSlot.removeAttribute(attribute1);
+                                }
+                            }
+                        });
+                        ev.delta.forEach(function(action) {
+                            if (Reflect.has(action, 'retain')) {
+                                if (action.attributes) {
+                                    var formats = remoteFormatsToLocal(_this.registry, action.attributes);
+                                    if (formats.length) {
+                                        localSlot.retain(action.retain, formats);
+                                    }
+                                }
+                                localSlot.retain(localSlot.index + action.retain);
+                            } else if (action.insert) {
+                                var index = localSlot.index;
+                                var length = 1;
+                                if (typeof action.insert === 'string') {
+                                    length = action.insert.length;
+                                    localSlot.insert(action.insert, remoteFormatsToLocal(_this.registry, action.attributes));
+                                } else {
+                                    var sharedComponent = action.insert;
+                                    var component = _this.createLocalComponentBySharedComponent(sharedComponent);
+                                    localSlot.insert(component);
+                                }
+                                if (_this.selection.isSelected && !_instanceof$1(tr.origin, UndoManager)) {
+                                    if (localSlot === _this.selection.anchorSlot && _this.selection.anchorOffset > index) {
+                                        _this.selection.setAnchor(localSlot, _this.selection.anchorOffset + length);
+                                    }
+                                    if (localSlot === _this.selection.focusSlot && _this.selection.focusOffset > index) {
+                                        _this.selection.setFocus(localSlot, _this.selection.focusOffset + length);
+                                    }
+                                }
+                            } else if (action.delete) {
+                                var index1 = localSlot.index;
+                                localSlot.delete(action.delete);
+                                if (_this.selection.isSelected && !_instanceof$1(tr.origin, UndoManager)) {
+                                    if (localSlot === _this.selection.anchorSlot && _this.selection.anchorOffset >= index1) {
+                                        _this.selection.setAnchor(localSlot, _this.selection.startOffset - action.delete);
+                                    }
+                                    if (localSlot === _this.selection.focusSlot && _this.selection.focusOffset >= index1) {
+                                        _this.selection.setFocus(localSlot, _this.selection.focusOffset - action.delete);
+                                    }
+                                }
+                            }
+                        });
+                    });
+                };
+                sharedSlot.observe(syncRemote);
+                var sub = localSlot.onContentChange.subscribe(function(actions) {
+                    _this.runLocalUpdate(sharedSlot.doc, true, function() {
+                        var offset = 0;
+                        var length = 0;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            var _loop = function() {
+                                var action = _step.value;
+                                if (action.type === 'retain') {
+                                    var formats = action.formats;
+                                    if (formats) {
+                                        var keys = Object.keys(formats);
+                                        var length1 = keys.length;
+                                        keys.forEach(function(key) {
+                                            var formatter = _this.registry.getFormatter(key);
+                                            if (!formatter) {
+                                                length1--;
+                                                Reflect.deleteProperty(formats, key);
+                                            }
+                                        });
+                                        if (length1) {
+                                            sharedSlot.format(offset, action.offset, formats);
+                                        }
+                                    } else {
+                                        offset = action.offset;
+                                    }
+                                } else if (action.type === 'contentInsert') {
+                                    var delta = sharedSlot.toDelta();
+                                    var isEmpty = delta.length === 1 && delta[0].insert === Slot.emptyPlaceholder;
+                                    if (typeof action.content === 'string') {
+                                        length = action.content.length;
+                                        sharedSlot.insert(offset, action.content, action.formats || {});
+                                    } else {
+                                        length = 1;
+                                        var sharedComponent = _this.createSharedComponentByLocalComponent(action.ref);
+                                        sharedSlot.insertEmbed(offset, sharedComponent, action.formats || {});
+                                    }
+                                    if (isEmpty && offset === 0) {
+                                        sharedSlot.delete(sharedSlot.length - 1, 1);
+                                    }
+                                    offset += length;
+                                } else if (action.type === 'delete') {
+                                    var delta1 = sharedSlot.toDelta();
+                                    if (sharedSlot.length) {
+                                        sharedSlot.delete(offset, action.count);
+                                    }
+                                    if (sharedSlot.length === 0) {
+                                        var _delta_;
+                                        sharedSlot.insert(0, '\n', (_delta_ = delta1[0]) === null || _delta_ === void 0 ? void 0 : _delta_.attributes);
+                                    }
+                                } else if (action.type === 'attrSet') {
+                                    sharedSlot.setAttribute(action.name, action.value);
+                                } else if (action.type === 'attrDelete') {
+                                    sharedSlot.removeAttribute(action.name);
+                                }
+                            };
+                            for(var _iterator = actions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    });
+                });
+                this.slotMap.set(localSlot, sharedSlot);
+                localSlot.__changeMarker__.addDetachCallback(function() {
+                    _this.slotMap.delete(localSlot);
+                    sharedSlot.unobserve(syncRemote);
+                    sub.unsubscribe();
+                });
+            }
+        },
+        {
+            key: "destroy",
+            value: function destroy() {
+                this.subscriptions.forEach(function(i) {
+                    return i.unsubscribe();
+                });
+                this.subscriptions = [];
+            }
+        },
+        {
+            key: "syncSharedMapToLocalMap",
+            value: function syncSharedMapToLocalMap(sharedMap, localMap) {
+                var _this = this;
+                sharedMap.forEach(function(value, key) {
+                    localMap[key] = _this.createLocalModelBySharedByModel(value);
+                });
+                this.syncObject(sharedMap, localMap);
+            }
+        },
+        {
+            key: "createLocalMapBySharedMap",
+            value: function createLocalMapBySharedMap(sharedMap) {
+                var localMap = observe({});
+                this.syncSharedMapToLocalMap(sharedMap, localMap);
+                return localMap;
+            }
+        },
+        {
+            key: "createLocalArrayBySharedArray",
+            value: function createLocalArrayBySharedArray(sharedArray) {
+                var _this = this;
+                var _localArray;
+                var localArray = observe([]);
+                (_localArray = localArray).push.apply(_localArray, _to_consumable_array(sharedArray.map(function(item) {
+                    return _this.createLocalModelBySharedByModel(item);
+                })));
+                this.syncArray(sharedArray, localArray);
+                return localArray;
+            }
+        },
+        {
+            key: "syncLocalMapToSharedMap",
+            value: function syncLocalMapToSharedMap(localMap, sharedMap) {
+                var _this = this;
+                Object.entries(localMap).forEach(function(param) {
+                    var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                    sharedMap.set(key, _this.createSharedModelByLocalModel(value));
+                });
+                this.syncObject(sharedMap, localMap);
+            }
+        },
+        {
+            key: "createSharedMapByLocalMap",
+            value: function createSharedMapByLocalMap(localMap) {
+                var sharedMap = new Map();
+                this.syncLocalMapToSharedMap(localMap, sharedMap);
+                return sharedMap;
+            }
+        },
+        {
+            key: "createSharedArrayByLocalArray",
+            value: function createSharedArrayByLocalArray(localArray) {
+                var _this = this;
+                var sharedArray = new Array$1();
+                localArray.forEach(function(value) {
+                    sharedArray.push([
+                        _this.createSharedModelByLocalModel(value)
+                    ]);
+                });
+                this.syncArray(sharedArray, localArray);
+                return sharedArray;
+            }
+        },
+        {
+            key: "createSharedSlotByLocalSlot",
+            value: function createSharedSlotByLocalSlot(localSlot) {
+                var _this = this;
+                var sharedSlot = new Text();
+                var isAsyncSlot = _instanceof$1(localSlot, AsyncSlot);
+                sharedSlot.setAttribute('schema', _to_consumable_array(localSlot.schema));
+                sharedSlot.setAttribute('type', isAsyncSlot ? 'async' : 'sync');
+                if (isAsyncSlot) {
+                    var isDestroyed = false;
+                    var sharedMetadata = this.createSharedMapByLocalMap(localSlot.metadata);
+                    sharedSlot.setAttribute('metadata', sharedMetadata);
+                    this.subModelLoader.createSubModelBySlot(localSlot).then(function(subDocument) {
+                        if (isDestroyed) {
+                            return;
+                        }
+                        var content = subDocument.getText('content');
+                        var state = subDocument.getMap('state');
+                        _this.syncLocalMapToSharedMap(localSlot.state, state);
+                        _this.initSharedSlotByLocalSlot(content, localSlot);
+                        _this.syncSlot(content, localSlot);
+                        _this.addSubModelEvent.next({
+                            yDoc: subDocument,
+                            yType: content
+                        });
+                        _this.initSyncEvent(subDocument);
+                        localSlot.loader.markAsLoaded();
+                    });
+                    localSlot.__changeMarker__.addDetachCallback(function() {
+                        isDestroyed = true;
+                    });
+                    return sharedSlot;
+                }
+                var sharedSlotState = new Map();
+                this.syncLocalMapToSharedMap(localSlot.state, sharedSlotState);
+                sharedSlot.setAttribute('state', sharedSlotState);
+                var sharedContent = new Text();
+                this.initSharedSlotByLocalSlot(sharedContent, localSlot);
+                sharedSlot.insertEmbed(0, sharedContent);
+                this.syncSlot(sharedContent, localSlot);
+                return sharedSlot;
+            }
+        },
+        {
+            key: "initSharedSlotByLocalSlot",
+            value: function initSharedSlotByLocalSlot(sharedContent, localSlot) {
+                var _this = this;
+                var offset = 0;
+                localSlot.toDelta().forEach(function(i) {
+                    var formats = {};
+                    if (i.formats) {
+                        i.formats.forEach(function(item) {
+                            formats[item[0].name] = item[1];
+                        });
+                    } else {
+                        formats = null;
+                    }
+                    if (typeof i.insert === 'string') {
+                        sharedContent.insert(offset, i.insert, formats);
+                    } else {
+                        var sharedComponent = _this.createSharedComponentByLocalComponent(i.insert);
+                        sharedContent.insertEmbed(offset, sharedComponent, formats);
+                    }
+                    offset += i.insert.length;
+                });
+                localSlot.getAttributes().forEach(function(item) {
+                    sharedContent.setAttribute(item[0].name, item[1]);
+                });
+            }
+        },
+        {
+            key: "createLocalSlotBySharedSlot",
+            value: function createLocalSlotBySharedSlot(sharedSlot) {
+                var _this = this;
+                var _contentDelta_;
+                var type = sharedSlot.getAttribute('type');
+                var schema = sharedSlot.getAttribute('schema');
+                if (type === 'async') {
+                    var metadata = sharedSlot.getAttribute('metadata');
+                    var slot = new AsyncSlot(schema || [], {}, {});
+                    this.syncSharedMapToLocalMap(metadata, slot.metadata);
+                    var loadedSubDocument = this.subModelLoader.getLoadedModelBySlot(slot);
+                    if (loadedSubDocument) {
+                        var subContent = loadedSubDocument.getText('content');
+                        var data = loadedSubDocument.getMap('state');
+                        this.syncSharedMapToLocalMap(data, slot.state);
+                        this.syncRootSlot(loadedSubDocument, subContent, slot);
+                        this.addSubModelEvent.next({
+                            yDoc: loadedSubDocument,
+                            yType: subContent
+                        });
+                        slot.loader.markAsLoaded();
+                        return slot;
+                    }
+                    var isDestroyed = false;
+                    slot.loader.onRequestLoad.toPromise().then(function() {
+                        return _this.subModelLoader.loadSubModelBySlot(slot);
+                    }).then(function(subDocument) {
+                        if (isDestroyed) {
+                            return;
+                        }
+                        var subContent = subDocument.getText('content');
+                        var state = subDocument.getMap('state');
+                        _this.syncSharedMapToLocalMap(state, slot.state);
+                        _this.syncRootSlot(subDocument, subContent, slot);
+                        _this.addSubModelEvent.next({
+                            yDoc: subDocument,
+                            yType: subContent
+                        });
+                        slot.loader.markAsLoaded();
+                    });
+                    slot.__changeMarker__.addDetachCallback(function() {
+                        isDestroyed = true;
+                    });
+                    return slot;
+                }
+                var contentDelta = sharedSlot.toDelta();
+                var content = (_contentDelta_ = contentDelta[0]) === null || _contentDelta_ === void 0 ? void 0 : _contentDelta_.insert;
+                if (!_instanceof$1(content, Text)) {
+                    throw collaborateErrorFn('shared slot content type is not `YText`.');
+                }
+                var localSlot = new Slot(schema || [], {});
+                var sharedSlotState = sharedSlot.getAttribute('state');
+                this.syncSharedMapToLocalMap(sharedSlotState, localSlot.state);
+                this.initLocalSlotBySharedSlot(content, localSlot);
+                this.syncSlot(content, localSlot);
+                return localSlot;
+            }
+        },
+        {
+            key: "initLocalSlotBySharedSlot",
+            value: function initLocalSlotBySharedSlot(content, localSlot) {
+                var _this = this;
+                var delta = content.toDelta();
+                var attrs = content.getAttributes();
+                Object.keys(attrs).forEach(function(key) {
+                    var attribute = _this.registry.getAttribute(key);
+                    if (attribute) {
+                        localSlot.setAttribute(attribute, attrs[key]);
+                    }
+                });
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = delta[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var action = _step.value;
+                        if (action.insert) {
+                            if (typeof action.insert === 'string') {
+                                var formats = remoteFormatsToLocal(this.registry, action.attributes);
+                                localSlot.insert(action.insert, formats);
+                            } else {
+                                var sharedComponent = action.insert;
+                                var component = this.createLocalComponentBySharedComponent(sharedComponent);
+                                localSlot.insert(component, remoteFormatsToLocal(this.registry, action.attributes));
+                            }
+                        } else {
+                            throw collaborateErrorFn('unexpected delta action.');
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "createSharedModelByLocalModel",
+            value: function createSharedModelByLocalModel(localModel) {
+                if (_instanceof$1(localModel, Slot)) {
+                    return this.createSharedSlotByLocalSlot(localModel);
+                }
+                if (Array.isArray(localModel)) {
+                    return this.createSharedArrayByLocalArray(localModel);
+                }
+                if ((typeof localModel === "undefined" ? "undefined" : _type_of$2(localModel)) === 'object' && localModel !== null) {
+                    return this.createSharedMapByLocalMap(localModel);
+                }
+                return localModel;
+            }
+        },
+        {
+            key: "createLocalModelBySharedByModel",
+            value: function createLocalModelBySharedByModel(sharedModel) {
+                if (_instanceof$1(sharedModel, Map)) {
+                    return this.createLocalMapBySharedMap(sharedModel);
+                }
+                if (_instanceof$1(sharedModel, Array$1)) {
+                    return this.createLocalArrayBySharedArray(sharedModel);
+                }
+                if (_instanceof$1(sharedModel, Text)) {
+                    return this.createLocalSlotBySharedSlot(sharedModel);
+                }
+                return sharedModel;
+            }
+        },
+        {
+            key: "createSharedComponentByLocalComponent",
+            value: function createSharedComponentByLocalComponent(component) {
+                var _this = this;
+                var sharedComponent = new Map();
+                sharedComponent.set('name', component.name);
+                if (_instanceof$1(component, AsyncComponent)) {
+                    sharedComponent.set('type', 'async');
+                    var sharedMetadata = this.createSharedMapByLocalMap(component.metadata);
+                    sharedComponent.set('metadata', sharedMetadata);
+                    var state = component.state;
+                    var isDestroyed = false;
+                    state.__changeMarker__.addDetachCallback(function() {
+                        isDestroyed = true;
+                    });
+                    this.subModelLoader.createSubModelByComponent(component).then(function(subDocument) {
+                        if (isDestroyed) {
+                            return;
+                        }
+                        var state = subDocument.getMap('state');
+                        _this.syncComponent(subDocument, state, component);
+                        _this.addSubModelEvent.next({
+                            yType: state,
+                            yDoc: subDocument
+                        });
+                        _this.initSyncEvent(subDocument);
+                        component.loader.markAsLoaded();
+                    });
+                    return sharedComponent;
+                }
+                var sharedState = this.createSharedMapByLocalMap(component.state);
+                sharedComponent.set('state', sharedState);
+                sharedComponent.set('type', 'sync');
+                return sharedComponent;
+            }
+        },
+        {
+            key: "createLocalComponentBySharedComponent",
+            value: function createLocalComponentBySharedComponent(yMap) {
+                var _this = this;
+                var componentName = yMap.get('name');
+                var type = yMap.get('type');
+                var instance;
+                if (type === 'async') {
+                    instance = this.registry.createComponentByData(componentName, {}, {});
+                    if (_instanceof$1(instance, AsyncComponent)) {
+                        var sharedMetadata = yMap.get('metadata');
+                        this.syncSharedMapToLocalMap(sharedMetadata, instance.metadata);
+                        var loadedSubDocument = this.subModelLoader.getLoadedModelByComponent(instance);
+                        if (loadedSubDocument) {
+                            var state = loadedSubDocument.getMap('state');
+                            this.syncComponent(loadedSubDocument, state, instance);
+                            this.addSubModelEvent.next({
+                                yType: state,
+                                yDoc: loadedSubDocument
+                            });
+                            instance.loader.markAsLoaded();
+                            return instance;
+                        }
+                        var state1 = instance.state;
+                        var isDestroyed = false;
+                        instance.loader.onRequestLoad.toPromise().then(function() {
+                            return _this.subModelLoader.loadSubModelByComponent(instance);
+                        }).then(function(subDocument) {
+                            if (isDestroyed) {
+                                return;
+                            }
+                            var state = subDocument.getMap('state');
+                            _this.syncComponent(subDocument, state, instance);
+                            _this.addSubModelEvent.next({
+                                yType: state,
+                                yDoc: subDocument
+                            });
+                            instance.loader.markAsLoaded();
+                        });
+                        state1.__changeMarker__.addDetachCallback(function() {
+                            isDestroyed = true;
+                        });
+                    } else if (_instanceof$1(instance, Component)) {
+                        throw collaborateErrorFn("component name `".concat(componentName, "` is not a async component."));
+                    }
+                } else {
+                    var sharedState = yMap.get('state');
+                    var state2 = this.createLocalMapBySharedMap(sharedState);
+                    instance = this.registry.createComponentByData(componentName, state2);
+                }
+                if (instance) {
+                    return instance;
+                }
+                throw collaborateErrorFn("cannot find component factory `".concat(componentName, "`."));
+            }
+        },
+        {
+            key: "syncArray",
+            value: /**
+   * 双向同步数组
+   * @param sharedArray
+   * @param localArray
+   * @private
+   */ function syncArray(sharedArray, localArray) {
+                var _this = this;
+                function logError(type) {
+                    console.error(collaborateErrorFn("".concat(type, " error, length exceeded, path in ").concat(localArray.__changeMarker__.getPaths().join('/'))));
+                }
+                var sub = localArray.__changeMarker__.onSelfChange.subscribe(function(actions) {
+                    _this.runLocalUpdate(sharedArray.doc, !localArray.__changeMarker__.irrevocableUpdate, function() {
+                        var index = 0;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = actions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var action = _step.value;
+                                switch(action.type){
+                                    case 'retain':
+                                        index = action.offset;
+                                        break;
+                                    case 'insert':
+                                        {
+                                            var ref = action.ref;
+                                            if (!Array.isArray(ref)) {
+                                                throw collaborateErrorFn('The insertion action must have a reference value.');
+                                            }
+                                            var data = ref.map(function(item) {
+                                                return _this.createSharedModelByLocalModel(item);
+                                            });
+                                            if (index <= sharedArray.length) {
+                                                sharedArray.insert(index, data);
+                                            } else {
+                                                sharedArray.insert(sharedArray.length, data);
+                                                logError('insert');
+                                            }
+                                        }
+                                        break;
+                                    case 'delete':
+                                        if (action.count <= 0) {
+                                            break;
+                                        }
+                                        if (index < sharedArray.length) {
+                                            sharedArray.delete(index, action.count);
+                                        } else {
+                                            logError('delete');
+                                        }
+                                        break;
+                                    case 'setIndex':
+                                        if (action.index < sharedArray.length) {
+                                            sharedArray.delete(action.index, 1);
+                                            sharedArray.insert(action.index, [
+                                                _this.createSharedModelByLocalModel(action.ref)
+                                            ]);
+                                        } else {
+                                            sharedArray.insert(sharedArray.length, [
+                                                _this.createSharedModelByLocalModel(action.ref)
+                                            ]);
+                                            logError('setIndex');
+                                        }
+                                        break;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    });
+                });
+                var syncRemote = function syncRemote(ev, tr) {
+                    _this.runRemoteUpdate(tr, function() {
+                        var index = 0;
+                        ev.delta.forEach(function(action) {
+                            if (Reflect.has(action, 'retain')) {
+                                index += action.retain;
+                            } else if (action.insert) {
+                                var _localArray;
+                                var data = action.insert.map(function(item) {
+                                    return _this.createLocalModelBySharedByModel(item);
+                                });
+                                (_localArray = localArray).splice.apply(_localArray, [
+                                    index,
+                                    0
+                                ].concat(_to_consumable_array(data)));
+                                index += data.length;
+                            } else if (action.delete) {
+                                localArray.splice(index, action.delete);
+                            }
+                        });
+                    });
+                };
+                sharedArray.observe(syncRemote);
+                localArray.__changeMarker__.addDetachCallback(function() {
+                    sub.unsubscribe();
+                    sharedArray.unobserve(syncRemote);
+                });
+            }
+        },
+        {
+            key: "syncObject",
+            value: /**
+   * 双向同步对象
+   * @param sharedObject
+   * @param localObject
+   * @private
+   */ function syncObject(sharedObject, localObject) {
+                var _this = this;
+                var syncRemote = function syncRemote(ev, tr) {
+                    _this.runRemoteUpdate(tr, function() {
+                        ev.changes.keys.forEach(function(item, key) {
+                            if (item.action === 'add' || item.action === 'update') {
+                                var value = sharedObject.get(key);
+                                localObject[key] = _this.createLocalModelBySharedByModel(value);
+                            } else {
+                                Reflect.deleteProperty(localObject, key);
+                            }
+                        });
+                    });
+                };
+                sharedObject.observe(syncRemote);
+                var sub = localObject.__changeMarker__.onSelfChange.subscribe(function(actions) {
+                    _this.runLocalUpdate(sharedObject.doc, !localObject.__changeMarker__.irrevocableUpdate, function() {
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = actions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var action = _step.value;
+                                switch(action.type){
+                                    case 'propSet':
+                                        {
+                                            var subModel = _this.createSharedModelByLocalModel(action.ref);
+                                            sharedObject.set(action.key, subModel);
+                                            if (sharedObject.size === 0) {
+                                                // 奇怪的 bug，设置了子模型，但子模型会标记为 deleted，导致设置后无效
+                                                console.error(collaborateErrorFn("prop set error, key is ".concat(action.key)));
+                                            }
+                                        }
+                                        break;
+                                    case 'propDelete':
+                                        sharedObject.delete(action.key);
+                                        break;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    });
+                });
+                localObject.__changeMarker__.addDetachCallback(function() {
+                    sharedObject.unobserve(syncRemote);
+                    sub.unsubscribe();
+                });
+            }
+        },
+        {
+            key: "runLocalUpdate",
+            value: function runLocalUpdate(yDoc, record, fn) {
+                if (this.updateFromRemote || !yDoc) {
+                    return;
+                }
+                var changeList = this.updateRemoteActions.get(yDoc);
+                if (!changeList) {
+                    changeList = [];
+                    this.updateRemoteActions.set(yDoc, changeList);
+                }
+                changeList.push({
+                    record: record,
+                    action: fn
+                });
+            }
+        },
+        {
+            key: "runRemoteUpdate",
+            value: function runRemoteUpdate(tr, fn) {
+                if (tr.origin === tr.doc) {
+                    return;
+                }
+                this.updateFromRemote = true;
+                if (_instanceof$1(tr.origin, UndoManager)) {
+                    this.scheduler.historyApplyTransact(fn);
+                } else {
+                    this.scheduler.remoteUpdateTransact(fn);
+                }
+                this.updateFromRemote = false;
+            }
         }
-        const subContent = subDocument.getText("content");
-        const state = subDocument.getMap("state");
-        this.syncSharedMapToLocalMap(state, slot.state);
-        this.syncRootSlot(subDocument, subContent, slot);
-        this.addSubModelEvent.next({
-          yDoc: subDocument,
-          yType: subContent
+    ]);
+    return Collaborate;
+}();
+Collaborate = _ts_decorate$2([
+    Injectable(),
+    _ts_metadata$2("design:type", Function),
+    _ts_metadata$2("design:paramtypes", [
+        typeof Scheduler === "undefined" ? Object : Scheduler,
+        typeof Registry === "undefined" ? Object : Registry,
+        typeof Selection === "undefined" ? Object : Selection,
+        typeof SubModelLoader === "undefined" ? Object : SubModelLoader
+    ])
+], Collaborate);
+function remoteFormatsToLocal(registry, attrs) {
+    var formats = [];
+    if (attrs) {
+        Object.keys(attrs).forEach(function(key) {
+            var formatter = registry.getFormatter(key);
+            if (formatter) {
+                formats.push([
+                    formatter,
+                    attrs[key]
+                ]);
+            }
         });
-        slot.loader.markAsLoaded();
-      });
-      slot.__changeMarker__.addDetachCallback(() => {
-        isDestroyed = true;
-      });
-      return slot;
     }
-    const contentDelta = sharedSlot.toDelta();
-    const content = contentDelta[0]?.insert;
-    if (!(content instanceof Text)) {
-      throw collaborateErrorFn("shared slot content type is not `YText`.");
+    return formats;
+}
+
+function _class_call_check$7(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    const localSlot = new Slot(schema || [], {});
-    const sharedSlotState = sharedSlot.getAttribute("state");
-    this.syncSharedMapToLocalMap(sharedSlotState, localSlot.state);
-    this.initLocalSlotBySharedSlot(content, localSlot);
-    this.syncSlot(content, localSlot);
-    return localSlot;
-  }
-  initLocalSlotBySharedSlot(content, localSlot) {
-    const delta = content.toDelta();
-    const attrs = content.getAttributes();
-    Object.keys(attrs).forEach((key) => {
-      const attribute = this.registry.getAttribute(key);
-      if (attribute) {
-        localSlot.setAttribute(attribute, attrs[key]);
-      }
-    });
-    for (const action of delta) {
-      if (action.insert) {
-        if (typeof action.insert === "string") {
-          const formats = remoteFormatsToLocal(this.registry, action.attributes);
-          localSlot.insert(action.insert, formats);
-        } else {
-          const sharedComponent = action.insert;
-          const component = this.createLocalComponentBySharedComponent(sharedComponent);
-          localSlot.insert(component, remoteFormatsToLocal(this.registry, action.attributes));
-        }
-      } else {
-        throw collaborateErrorFn("unexpected delta action.");
-      }
+}
+function _defineProperties$6(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-  }
-  createSharedModelByLocalModel(localModel) {
-    if (localModel instanceof Slot) {
-      return this.createSharedSlotByLocalSlot(localModel);
+}
+function _create_class$6(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$6(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    if (Array.isArray(localModel)) {
-      return this.createSharedArrayByLocalArray(localModel);
+    return obj;
+}
+function _ts_decorate$1(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata$1(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param$1(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+var CustomUndoManagerConfig = function CustomUndoManagerConfig() {
+    _class_call_check$7(this, CustomUndoManagerConfig);
+};
+var collabHistoryErrorFn = makeError('CollabHistory');
+var CollabHistory = /*#__PURE__*/ function() {
+    function CollabHistory(rootComponentRef, collaborate, scheduler, stackSize, undoManagerConfig) {
+        _class_call_check$7(this, CollabHistory);
+        _define_property$7(this, "rootComponentRef", void 0);
+        _define_property$7(this, "collaborate", void 0);
+        _define_property$7(this, "scheduler", void 0);
+        _define_property$7(this, "stackSize", void 0);
+        _define_property$7(this, "undoManagerConfig", void 0);
+        _define_property$7(this, "onBack", void 0);
+        _define_property$7(this, "onForward", void 0);
+        _define_property$7(this, "onChange", void 0);
+        _define_property$7(this, "onPush", void 0);
+        _define_property$7(this, "manager", void 0);
+        _define_property$7(this, "historyItems", void 0);
+        _define_property$7(this, "index", void 0);
+        _define_property$7(this, "subscriptions", void 0);
+        _define_property$7(this, "backEvent", void 0);
+        _define_property$7(this, "forwardEvent", void 0);
+        _define_property$7(this, "changeEvent", void 0);
+        _define_property$7(this, "pushEvent", void 0);
+        this.rootComponentRef = rootComponentRef;
+        this.collaborate = collaborate;
+        this.scheduler = scheduler;
+        this.stackSize = stackSize;
+        this.undoManagerConfig = undoManagerConfig;
+        this.manager = null;
+        this.historyItems = [];
+        this.index = 0;
+        this.subscriptions = [];
+        this.backEvent = new Subject();
+        this.forwardEvent = new Subject();
+        this.changeEvent = new Subject();
+        this.pushEvent = new Subject();
+        this.onBack = this.backEvent.asObservable();
+        this.onForward = this.forwardEvent.asObservable();
+        this.onChange = this.changeEvent.asObservable();
+        this.onPush = this.pushEvent.asObservable();
     }
-    if (typeof localModel === "object" && localModel !== null) {
-      return this.createSharedMapByLocalMap(localModel);
+    _create_class$6(CollabHistory, [
+        {
+            key: "canBack",
+            get: function get() {
+                var _this_manager;
+                return ((_this_manager = this.manager) === null || _this_manager === void 0 ? void 0 : _this_manager.canUndo()) || false;
+            }
+        },
+        {
+            key: "canForward",
+            get: function get() {
+                var _this_manager;
+                return ((_this_manager = this.manager) === null || _this_manager === void 0 ? void 0 : _this_manager.canRedo()) || false;
+            }
+        },
+        {
+            key: "listen",
+            value: function listen() {
+                var _this = this;
+                var root = this.collaborate.yDoc.getMap('RootComponent');
+                var rootComponent = this.rootComponentRef.component;
+                this.collaborate.syncRootComponent(this.collaborate.yDoc, root, rootComponent);
+                var undoManagerConfig = this.undoManagerConfig || {};
+                var manager = new UndoManager(root, {
+                    trackedOrigins: new Set([
+                        this.collaborate.yDoc
+                    ]),
+                    captureTransaction: function captureTransaction(arg) {
+                        if (undoManagerConfig.captureTransaction) {
+                            return undoManagerConfig.captureTransaction(arg);
+                        }
+                        return true;
+                    },
+                    deleteFilter: function deleteFilter(item) {
+                        if (undoManagerConfig.deleteFilter) {
+                            return undoManagerConfig.deleteFilter(item);
+                        }
+                        return true;
+                    }
+                });
+                this.manager = manager;
+                var beforePosition = null;
+                this.subscriptions.push(this.scheduler.onLocalChangeBefore.subscribe(function() {
+                    beforePosition = _this.collaborate.getRelativeCursorLocation();
+                }), this.collaborate.onAddSubModel.subscribe(function() {
+                    throw collabHistoryErrorFn('single document does not support submodels.');
+                }));
+                manager.on('stack-item-added', function(event) {
+                    if (event.type === 'undo') {
+                        if (event.origin === manager) {
+                            _this.index++;
+                        } else {
+                            _this.historyItems.length = _this.index;
+                            _this.historyItems.push({
+                                before: beforePosition,
+                                after: _this.collaborate.getRelativeCursorLocation()
+                            });
+                            _this.index++;
+                        }
+                    } else {
+                        _this.index--;
+                    }
+                    if (manager.undoStack.length > _this.stackSize) {
+                        _this.historyItems.shift();
+                        manager.undoStack.shift();
+                    }
+                    if (event.origin === _this.collaborate.yDoc) {
+                        _this.pushEvent.next();
+                    }
+                    _this.changeEvent.next();
+                });
+                manager.on('stack-item-popped', function(ev) {
+                    var index = ev.type === 'undo' ? _this.index : _this.index - 1;
+                    var position = _this.historyItems[index] || null;
+                    var p = ev.type === 'undo' ? position === null || position === void 0 ? void 0 : position.before : position === null || position === void 0 ? void 0 : position.after;
+                    _this.collaborate.restoreCursorPosition(p);
+                });
+            }
+        },
+        {
+            key: "back",
+            value: function back() {
+                if (this.canBack) {
+                    var _this_manager;
+                    (_this_manager = this.manager) === null || _this_manager === void 0 ? void 0 : _this_manager.undo();
+                    this.backEvent.next();
+                }
+            }
+        },
+        {
+            key: "forward",
+            value: function forward() {
+                if (this.canForward) {
+                    var _this_manager;
+                    (_this_manager = this.manager) === null || _this_manager === void 0 ? void 0 : _this_manager.redo();
+                    this.forwardEvent.next();
+                }
+            }
+        },
+        {
+            key: "clear",
+            value: function clear() {
+                var _this_manager;
+                var last = this.historyItems.pop();
+                this.historyItems = last ? [
+                    last
+                ] : [];
+                this.index = last ? 1 : 0;
+                (_this_manager = this.manager) === null || _this_manager === void 0 ? void 0 : _this_manager.clear();
+                this.changeEvent.next();
+            }
+        },
+        {
+            key: "destroy",
+            value: function destroy() {
+                this.index = 0;
+                this.historyItems = [];
+                this.subscriptions.forEach(function(i) {
+                    return i.unsubscribe();
+                });
+                if (this.manager) {
+                    this.manager.destroy();
+                    this.manager.captureTransaction = function() {
+                        return true;
+                    };
+                    this.manager.deleteFilter = function() {
+                        return true;
+                    };
+                    this.manager.trackedOrigins = new Set([
+                        null
+                    ]);
+                }
+                this.manager = null;
+            }
+        }
+    ]);
+    return CollabHistory;
+}();
+CollabHistory = _ts_decorate$1([
+    Injectable(),
+    _ts_param$1(3, Inject(HISTORY_STACK_SIZE)),
+    _ts_param$1(4, Optional()),
+    _ts_metadata$1("design:type", Function),
+    _ts_metadata$1("design:paramtypes", [
+        typeof RootComponentRef === "undefined" ? Object : RootComponentRef,
+        typeof Collaborate === "undefined" ? Object : Collaborate,
+        typeof Scheduler === "undefined" ? Object : Scheduler,
+        Number,
+        typeof CustomUndoManagerConfig === "undefined" ? Object : CustomUndoManagerConfig
+    ])
+], CollabHistory);
+
+function _class_call_check$6(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    return localModel;
-  }
-  createLocalModelBySharedByModel(sharedModel) {
-    if (sharedModel instanceof Map) {
-      return this.createLocalMapBySharedMap(sharedModel);
+}
+function _defineProperties$5(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    if (sharedModel instanceof Array$1) {
-      return this.createLocalArrayBySharedArray(sharedModel);
+}
+function _create_class$5(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    if (sharedModel instanceof Text) {
-      return this.createLocalSlotBySharedSlot(sharedModel);
+    return obj;
+}
+/**
+ * 协作消息总线，用于同步各终端消息
+ */ var MessageBus = /*#__PURE__*/ function() {
+    function MessageBus() {
+        _class_call_check$6(this, MessageBus);
+        _define_property$6(this, "onSync", void 0);
+        _define_property$6(this, "syncEvent", new Subject());
+        this.onSync = this.syncEvent.asObservable();
     }
-    return sharedModel;
-  }
-  createSharedComponentByLocalComponent(component) {
-    const sharedComponent = new Map();
-    sharedComponent.set("name", component.name);
-    if (component instanceof AsyncComponent) {
-      sharedComponent.set("type", "async");
-      const sharedMetadata = this.createSharedMapByLocalMap(component.metadata);
-      sharedComponent.set("metadata", sharedMetadata);
-      const state = component.state;
-      let isDestroyed = false;
-      state.__changeMarker__.addDetachCallback(() => {
-        isDestroyed = true;
-      });
-      this.subModelLoader.createSubModelByComponent(component).then((subDocument) => {
-        if (isDestroyed) {
-          return;
+    _create_class$5(MessageBus, [
+        {
+            /**
+   * 立即同步消息
+   */ key: "sync",
+            value: function sync() {
+                this.syncEvent.next();
+            }
         }
-        const state2 = subDocument.getMap("state");
-        this.syncComponent(subDocument, state2, component);
-        this.addSubModelEvent.next({
-          yType: state2,
-          yDoc: subDocument
-        });
-        this.initSyncEvent(subDocument);
-        component.loader.markAsLoaded();
-      });
-      return sharedComponent;
+    ]);
+    return MessageBus;
+}();
+
+function _class_call_check$5(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    const sharedState = this.createSharedMapByLocalMap(component.state);
-    sharedComponent.set("state", sharedState);
-    sharedComponent.set("type", "sync");
-    return sharedComponent;
-  }
-  createLocalComponentBySharedComponent(yMap) {
-    const componentName = yMap.get("name");
-    const type = yMap.get("type");
-    let instance;
-    if (type === "async") {
-      instance = this.registry.createComponentByData(componentName, {}, {});
-      if (instance instanceof AsyncComponent) {
-        const sharedMetadata = yMap.get("metadata");
-        this.syncSharedMapToLocalMap(sharedMetadata, instance.metadata);
-        const loadedSubDocument = this.subModelLoader.getLoadedModelByComponent(instance);
-        if (loadedSubDocument) {
-          const state2 = loadedSubDocument.getMap("state");
-          this.syncComponent(loadedSubDocument, state2, instance);
-          this.addSubModelEvent.next({
-            yType: state2,
-            yDoc: loadedSubDocument
-          });
-          instance.loader.markAsLoaded();
-          return instance;
-        }
-        const state = instance.state;
-        let isDestroyed = false;
-        instance.loader.onRequestLoad.toPromise().then(() => {
-          return this.subModelLoader.loadSubModelByComponent(instance);
-        }).then((subDocument) => {
-          if (isDestroyed) {
-            return;
-          }
-          const state2 = subDocument.getMap("state");
-          this.syncComponent(subDocument, state2, instance);
-          this.addSubModelEvent.next({
-            yType: state2,
-            yDoc: subDocument
-          });
-          instance.loader.markAsLoaded();
-        });
-        state.__changeMarker__.addDetachCallback(() => {
-          isDestroyed = true;
+}
+function _defineProperties$4(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$4(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$4(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-      } else if (instance instanceof Component) {
-        throw collaborateErrorFn(`component name \`${componentName}\` is not a async component.`);
-      }
     } else {
-      const sharedState = yMap.get("state");
-      const state = this.createLocalMapBySharedMap(sharedState);
-      instance = this.registry.createComponentByData(componentName, state);
+        obj[key] = value;
     }
-    if (instance) {
-      return instance;
+    return obj;
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
     }
-    throw collaborateErrorFn(`cannot find component factory \`${componentName}\`.`);
-  }
-  /**
-   * 双向同步数组
-   * @param sharedArray
-   * @param localArray
-   * @private
-   */
-  syncArray(sharedArray, localArray) {
-    function logError(type) {
-      console.error(collaborateErrorFn(`${type} error, length exceeded, path in ${localArray.__changeMarker__.getPaths().join("/")}`));
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+var MultipleDocCollabHistory = /*#__PURE__*/ function() {
+    function MultipleDocCollabHistory(collaborate, scheduler, rootComponentRef, stackSize, undoManagerConfig) {
+        _class_call_check$5(this, MultipleDocCollabHistory);
+        _define_property$5(this, "collaborate", void 0);
+        _define_property$5(this, "scheduler", void 0);
+        _define_property$5(this, "rootComponentRef", void 0);
+        _define_property$5(this, "stackSize", void 0);
+        _define_property$5(this, "undoManagerConfig", void 0);
+        _define_property$5(this, "onChange", void 0);
+        _define_property$5(this, "onBack", void 0);
+        _define_property$5(this, "onForward", void 0);
+        _define_property$5(this, "onPush", void 0);
+        _define_property$5(this, "isListen", void 0);
+        _define_property$5(this, "changeEvent", void 0);
+        _define_property$5(this, "backEvent", void 0);
+        _define_property$5(this, "forwardEvent", void 0);
+        _define_property$5(this, "pushEvent", void 0);
+        _define_property$5(this, "actionStack", void 0);
+        _define_property$5(this, "index", void 0);
+        _define_property$5(this, "stackItem", void 0);
+        _define_property$5(this, "timer", void 0);
+        _define_property$5(this, "beforePosition", void 0);
+        _define_property$5(this, "subscription", void 0);
+        _define_property$5(this, "subDocs", void 0);
+        _define_property$5(this, "listenerCaches", void 0);
+        this.collaborate = collaborate;
+        this.scheduler = scheduler;
+        this.rootComponentRef = rootComponentRef;
+        this.stackSize = stackSize;
+        this.undoManagerConfig = undoManagerConfig;
+        this.isListen = false;
+        this.changeEvent = new Subject();
+        this.backEvent = new Subject();
+        this.forwardEvent = new Subject();
+        this.pushEvent = new Subject();
+        this.actionStack = [];
+        this.index = 0;
+        this.stackItem = null;
+        this.timer = null;
+        this.beforePosition = null;
+        this.subscription = new Subscription();
+        this.subDocs = new Set();
+        this.listenerCaches = new Set();
+        this.onChange = this.changeEvent.asObservable();
+        this.onBack = this.backEvent.asObservable();
+        this.onForward = this.forwardEvent.asObservable();
+        this.onPush = this.pushEvent.asObservable();
     }
-    const sub = localArray.__changeMarker__.onSelfChange.subscribe((actions) => {
-      this.runLocalUpdate(sharedArray.doc, !localArray.__changeMarker__.irrevocableUpdate, () => {
-        let index = 0;
-        for (const action of actions) {
-          switch (action.type) {
-            case "retain":
-              index = action.offset;
-              break;
-            case "insert":
-              {
-                const ref = action.ref;
-                if (!Array.isArray(ref)) {
-                  throw collaborateErrorFn("The insertion action must have a reference value.");
+    _create_class$4(MultipleDocCollabHistory, [
+        {
+            key: "canBack",
+            get: function get() {
+                return this.actionStack.length > 0 && this.index > 0;
+            }
+        },
+        {
+            key: "canForward",
+            get: function get() {
+                return this.actionStack.length > 0 && this.index < this.actionStack.length;
+            }
+        },
+        {
+            key: "listen",
+            value: function listen() {
+                var _this = this;
+                this.isListen = true;
+                var root = this.collaborate.yDoc.getMap('RootComponent');
+                var rootComponent = this.rootComponentRef.component;
+                this.collaborate.syncRootComponent(this.collaborate.yDoc, root, rootComponent);
+                this.listenItem(root, this.collaborate.yDoc);
+                this.subscription.add(this.collaborate.onAddSubModel.subscribe(function(param) {
+                    var yType = param.yType, yDoc = param.yDoc;
+                    if (_this.subDocs.has(yType)) {
+                        return;
+                    }
+                    _this.subDocs.add(yType);
+                    if (_this.isListen) {
+                        _this.listenItem(yType, yDoc);
+                    }
+                }), this.scheduler.onLocalChangeBefore.subscribe(function() {
+                    _this.beforePosition = _this.collaborate.getRelativeCursorLocation();
+                }));
+            }
+        },
+        {
+            key: "forward",
+            value: function forward() {
+                if (!this.canForward) {
+                    return;
                 }
-                const data = ref.map((item) => {
-                  return this.createSharedModelByLocalModel(item);
-                });
-                if (index <= sharedArray.length) {
-                  sharedArray.insert(index, data);
+                clearTimeout(this.timer);
+                var item = this.actionStack[this.index];
+                if (item) {
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = item.undoManagers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var i = _step.value;
+                            i.redo();
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    this.collaborate.restoreCursorPosition(item.after);
+                }
+                this.index++;
+                this.forwardEvent.next();
+                this.changeEvent.next();
+            }
+        },
+        {
+            key: "back",
+            value: function back() {
+                if (!this.canBack) {
+                    return;
+                }
+                clearTimeout(this.timer);
+                var historyStackItem;
+                if (this.stackItem) {
+                    historyStackItem = this.stackItem;
+                    this.stackItem = null;
                 } else {
-                  sharedArray.insert(sharedArray.length, data);
-                  logError("insert");
+                    this.index--;
+                    historyStackItem = this.actionStack[this.index];
+                }
+                var len = historyStackItem.undoManagers.length;
+                while(len > 0){
+                    len--;
+                    historyStackItem.undoManagers[len].undo();
+                }
+                if (historyStackItem) {
+                    var beforePosition = historyStackItem.before;
+                    this.collaborate.restoreCursorPosition(beforePosition);
+                    this.backEvent.next();
+                    this.changeEvent.next();
                 }
-              }
-              break;
-            case "delete":
-              if (action.count <= 0) {
-                break;
-              }
-              if (index < sharedArray.length) {
-                sharedArray.delete(index, action.count);
-              } else {
-                logError("delete");
-              }
-              break;
-            case "setIndex":
-              if (action.index < sharedArray.length) {
-                sharedArray.delete(action.index, 1);
-                sharedArray.insert(action.index, [this.createSharedModelByLocalModel(action.ref)]);
-              } else {
-                sharedArray.insert(sharedArray.length, [this.createSharedModelByLocalModel(action.ref)]);
-                logError("setIndex");
-              }
-              break;
-          }
+            }
+        },
+        {
+            key: "clear",
+            value: function clear() {
+                this.actionStack = [];
+                this.stackItem = null;
+                this.index = 0;
+                this.beforePosition = null;
+                clearTimeout(this.timer);
+                this.listenerCaches.forEach(function(undoManager) {
+                    undoManager.clear();
+                });
+                this.changeEvent.next();
+            }
+        },
+        {
+            key: "destroy",
+            value: function destroy() {
+                this.clear();
+                this.beforePosition = this.stackItem = null;
+                this.subscription.unsubscribe();
+                this.listenerCaches.forEach(function(undoManager) {
+                    undoManager.destroy();
+                });
+                this.subDocs.clear();
+                this.listenerCaches.clear();
+            }
+        },
+        {
+            key: "listenItem",
+            value: function listenItem(yType, yDoc) {
+                var _this = this;
+                var undoManagerConfig = this.undoManagerConfig || {};
+                var undoManager = new UndoManager(yType, {
+                    trackedOrigins: new Set([
+                        yDoc
+                    ]),
+                    captureTimeout: 0,
+                    captureTransaction: function captureTransaction(arg) {
+                        if (undoManagerConfig.captureTransaction) {
+                            return undoManagerConfig.captureTransaction(arg);
+                        }
+                        return true;
+                    },
+                    deleteFilter: function deleteFilter(item) {
+                        if (undoManagerConfig.deleteFilter) {
+                            return undoManagerConfig.deleteFilter(item);
+                        }
+                        return true;
+                    }
+                });
+                undoManager.on('stack-item-added', function(event) {
+                    if (event.type === 'undo' && !_instanceof(event.origin, UndoManager)) {
+                        if (_this.index != _this.actionStack.length) {
+                            var redoStack = _this.actionStack.slice(_this.index);
+                            redoStack.forEach(function(item) {
+                                item.undoManagers.forEach(function(i) {
+                                    i.clear(false, true);
+                                });
+                            });
+                            _this.actionStack.length = _this.index;
+                            _this.changeEvent.next();
+                        }
+                        if (_this.stackItem === null) {
+                            _this.stackItem = {
+                                before: _this.beforePosition,
+                                after: null,
+                                undoManagers: []
+                            };
+                            _this.timer = setTimeout(function() {
+                                if (_this.actionStack.length >= _this.stackSize) {
+                                    _this.actionStack.shift();
+                                } else {
+                                    _this.index++;
+                                }
+                                // this.beforePosition = this.collaborate.getRelativeCursorLocation()
+                                _this.stackItem.after = _this.beforePosition;
+                                _this.actionStack.push(_this.stackItem);
+                                _this.stackItem = null;
+                                _this.pushEvent.next();
+                                _this.changeEvent.next();
+                            }, 500);
+                        }
+                        _this.stackItem.undoManagers.push(undoManager);
+                    }
+                });
+                this.listenerCaches.add(undoManager);
+            }
         }
-      });
-    });
-    const syncRemote = (ev, tr) => {
-      this.runRemoteUpdate(tr, () => {
-        let index = 0;
-        ev.delta.forEach((action) => {
-          if (Reflect.has(action, "retain")) {
-            index += action.retain;
-          } else if (action.insert) {
-            const data = action.insert.map((item) => {
-              return this.createLocalModelBySharedByModel(item);
-            });
-            localArray.splice(index, 0, ...data);
-            index += data.length;
-          } else if (action.delete) {
-            localArray.splice(index, action.delete);
-          }
+    ]);
+    return MultipleDocCollabHistory;
+}();
+MultipleDocCollabHistory = _ts_decorate([
+    Injectable(),
+    _ts_param(3, Inject(HISTORY_STACK_SIZE)),
+    _ts_param(4, Optional()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Collaborate === "undefined" ? Object : Collaborate,
+        typeof Scheduler === "undefined" ? Object : Scheduler,
+        typeof RootComponentRef === "undefined" ? Object : RootComponentRef,
+        Number,
+        typeof CustomUndoManagerConfig === "undefined" ? Object : CustomUndoManagerConfig
+    ])
+], MultipleDocCollabHistory);
+
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-      });
-    };
-    sharedArray.observe(syncRemote);
-    localArray.__changeMarker__.addDetachCallback(() => {
-      sub.unsubscribe();
-      sharedArray.unobserve(syncRemote);
-    });
-  }
-  /**
-   * 双向同步对象
-   * @param sharedObject
-   * @param localObject
-   * @private
-   */
-  syncObject(sharedObject, localObject) {
-    const syncRemote = (ev, tr) => {
-      this.runRemoteUpdate(tr, () => {
-        ev.changes.keys.forEach((item, key) => {
-          if (item.action === "add" || item.action === "update") {
-            const value = sharedObject.get(key);
-            localObject[key] = this.createLocalModelBySharedByModel(value);
-          } else {
-            Reflect.deleteProperty(localObject, key);
-          }
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * 协作通信通用接口
+ */ var SyncConnector = function SyncConnector() {
+    _class_call_check$4(this, SyncConnector);
+    /**
+   * 当文档加载完成时触发的观察者
+   */ _define_property$4(this, "onLoad", void 0);
+    /**
+   * 当文档 awareness 状态变更时触发的观察者
+   */ _define_property$4(this, "onStateChange", void 0);
+    _define_property$4(this, "loadEvent", new Subject());
+    _define_property$4(this, "stateChangeEvent", new Subject());
+    this.onLoad = this.loadEvent.asObservable();
+    this.onStateChange = this.stateChangeEvent.asObservable();
+};
+
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$3(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 _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
     };
-    sharedObject.observe(syncRemote);
-    const sub = localObject.__changeMarker__.onSelfChange.subscribe((actions) => {
-      this.runLocalUpdate(sharedObject.doc, !localObject.__changeMarker__.irrevocableUpdate, () => {
-        for (const action of actions) {
-          switch (action.type) {
-            case "propSet":
-              {
-                const subModel = this.createSharedModelByLocalModel(action.ref);
-                sharedObject.set(action.key, subModel);
-                if (sharedObject.size === 0) {
-                  console.error(collaborateErrorFn(`prop set error, key is ${action.key}`));
-                }
-              }
-              break;
-            case "propDelete":
-              sharedObject.delete(action.key);
-              break;
-          }
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
         }
-      });
-    });
-    localObject.__changeMarker__.addDetachCallback(function() {
-      sharedObject.unobserve(syncRemote);
-      sub.unsubscribe();
     });
-  }
-  runLocalUpdate(yDoc, record, fn) {
-    if (this.updateFromRemote || !yDoc) {
-      return;
-    }
-    let changeList = this.updateRemoteActions.get(yDoc);
-    if (!changeList) {
-      changeList = [];
-      this.updateRemoteActions.set(yDoc, changeList);
+    if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _object_spread(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) {
+            _define_property$3(target, key, source[key]);
+        });
     }
-    changeList.push({
-      record,
-      action: fn
-    });
-  }
-  runRemoteUpdate(tr, fn) {
-    if (tr.origin === tr.doc) {
-      return;
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
     }
-    this.updateFromRemote = true;
-    if (tr.origin instanceof UndoManager) {
-      this.scheduler.historyApplyTransact(fn);
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     } else {
-      this.scheduler.remoteUpdateTransact(fn);
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
     }
-    this.updateFromRemote = false;
-  }
-};
-Collaborate = __decorateClass$2([
-  Injectable()
-], Collaborate);
-function remoteFormatsToLocal(registry, attrs) {
-  const formats = [];
-  if (attrs) {
-    Object.keys(attrs).forEach((key) => {
-      const formatter = registry.getFormatter(key);
-      if (formatter) {
-        formats.push([formatter, attrs[key]]);
-      }
-    });
-  }
-  return formats;
-}
-class MessageBus {
-  onSync;
-  syncEvent = new Subject();
-  constructor() {
-    this.onSync = this.syncEvent.asObservable();
-  }
-  /**
-   * 立即同步消息
-   */
-  sync() {
-    this.syncEvent.next();
-  }
-}
-var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
-var __decorateClass$1 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(result) || result;
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-let MultipleDocCollabHistory = class {
-  constructor(collaborate, scheduler, rootComponentRef, stackSize, undoManagerConfig) {
-    this.collaborate = collaborate;
-    this.scheduler = scheduler;
-    this.rootComponentRef = rootComponentRef;
-    this.stackSize = stackSize;
-    this.undoManagerConfig = undoManagerConfig;
-    this.onChange = this.changeEvent.asObservable();
-    this.onBack = this.backEvent.asObservable();
-    this.onForward = this.forwardEvent.asObservable();
-    this.onPush = this.pushEvent.asObservable();
-  }
-  collaborate;
-  scheduler;
-  rootComponentRef;
-  stackSize;
-  undoManagerConfig;
-  onChange;
-  onBack;
-  onForward;
-  onPush;
-  get canBack() {
-    return this.actionStack.length > 0 && this.index > 0;
-  }
-  get canForward() {
-    return this.actionStack.length > 0 && this.index < this.actionStack.length;
-  }
-  isListen = false;
-  changeEvent = new Subject();
-  backEvent = new Subject();
-  forwardEvent = new Subject();
-  pushEvent = new Subject();
-  actionStack = [];
-  index = 0;
-  stackItem = null;
-  timer = null;
-  beforePosition = null;
-  subscription = new Subscription();
-  subDocs = /* @__PURE__ */ new Set();
-  listenerCaches = /* @__PURE__ */ new Set();
-  listen() {
-    this.isListen = true;
-    const root = this.collaborate.yDoc.getMap("RootComponent");
-    const rootComponent = this.rootComponentRef.component;
-    this.collaborate.syncRootComponent(this.collaborate.yDoc, root, rootComponent);
-    this.listenItem(root, this.collaborate.yDoc);
-    this.subscription.add(
-      this.collaborate.onAddSubModel.subscribe(({ yType, yDoc }) => {
-        if (this.subDocs.has(yType)) {
-          return;
-        }
-        this.subDocs.add(yType);
-        if (this.isListen) {
-          this.listenItem(yType, yDoc);
+    return target;
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
+var HocuspocusConnector = /*#__PURE__*/ function(SyncConnector) {
+    _inherits$1(HocuspocusConnector, SyncConnector);
+    function HocuspocusConnector(config) {
+        _class_call_check$3(this, HocuspocusConnector);
+        var _this;
+        _this = _call_super$1(this, HocuspocusConnector), _define_property$3(_this, "provide", void 0);
+        _this.provide = new HocuspocusProvider(_object_spread_props(_object_spread({}, config), {
+            onSynced: function onSynced(data) {
+                var _config_onSynced;
+                (_config_onSynced = config.onSynced) === null || _config_onSynced === void 0 ? void 0 : _config_onSynced.call(config, data);
+                _this.loadEvent.next();
+            },
+            onAwarenessUpdate: function onAwarenessUpdate(data) {
+                var _config_onAwarenessUpdate;
+                (_config_onAwarenessUpdate = config.onAwarenessUpdate) === null || _config_onAwarenessUpdate === void 0 ? void 0 : _config_onAwarenessUpdate.call(config, data);
+                var states = data.states.map(function(state) {
+                    return {
+                        clientId: state.clientId,
+                        message: state.message
+                    };
+                });
+                _this.stateChangeEvent.next(states);
+            }
+        }));
+        return _this;
+    }
+    _create_class$3(HocuspocusConnector, [
+        {
+            key: "setLocalStateField",
+            value: function setLocalStateField(key, data) {
+                this.provide.setAwarenessField(key, data);
+            }
+        },
+        {
+            key: "onDestroy",
+            value: function onDestroy() {
+                this.provide.disconnect();
+                this.provide.destroy();
+            }
         }
-      }),
-      this.scheduler.onLocalChangeBefore.subscribe(() => {
-        this.beforePosition = this.collaborate.getRelativeCursorLocation();
-      })
-    );
-  }
-  forward() {
-    if (!this.canForward) {
-      return;
+    ]);
+    return HocuspocusConnector;
+}(SyncConnector);
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
-    clearTimeout(this.timer);
-    const item = this.actionStack[this.index];
-    if (item) {
-      for (const i of item.undoManagers) {
-        i.redo();
-      }
-      this.collaborate.restoreCursorPosition(item.after);
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    this.index++;
-    this.forwardEvent.next();
-    this.changeEvent.next();
-  }
-  back() {
-    if (!this.canBack) {
-      return;
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    clearTimeout(this.timer);
-    let historyStackItem;
-    if (this.stackItem) {
-      historyStackItem = this.stackItem;
-      this.stackItem = null;
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
     } else {
-      this.index--;
-      historyStackItem = this.actionStack[this.index];
-    }
-    let len = historyStackItem.undoManagers.length;
-    while (len > 0) {
-      len--;
-      historyStackItem.undoManagers[len].undo();
+        obj[key] = value;
     }
-    if (historyStackItem) {
-      const beforePosition = historyStackItem.before;
-      this.collaborate.restoreCursorPosition(beforePosition);
-      this.backEvent.next();
-      this.changeEvent.next();
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
     }
-  }
-  clear() {
-    this.actionStack = [];
-    this.stackItem = null;
-    this.index = 0;
-    this.beforePosition = null;
-    clearTimeout(this.timer);
-    this.listenerCaches.forEach((undoManager) => {
-      undoManager.clear();
-    });
-    this.changeEvent.next();
-  }
-  destroy() {
-    this.clear();
-    this.beforePosition = this.stackItem = null;
-    this.subscription.unsubscribe();
-    this.listenerCaches.forEach((undoManager) => {
-      undoManager.destroy();
-    });
-    this.subDocs.clear();
-    this.listenerCaches.clear();
-  }
-  listenItem(yType, yDoc) {
-    const undoManagerConfig = this.undoManagerConfig || {};
-    const undoManager = new UndoManager(yType, {
-      trackedOrigins: /* @__PURE__ */ new Set([yDoc]),
-      captureTimeout: 0,
-      captureTransaction(arg) {
-        if (undoManagerConfig.captureTransaction) {
-          return undoManagerConfig.captureTransaction(arg);
-        }
-        return true;
-      },
-      deleteFilter(item) {
-        if (undoManagerConfig.deleteFilter) {
-          return undoManagerConfig.deleteFilter(item);
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
         }
-        return true;
-      }
     });
-    undoManager.on("stack-item-added", (event) => {
-      if (event.type === "undo" && !(event.origin instanceof UndoManager)) {
-        if (this.index != this.actionStack.length) {
-          const redoStack = this.actionStack.slice(this.index);
-          redoStack.forEach((item) => {
-            item.undoManagers.forEach((i) => {
-              i.clear(false, true);
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var YWebsocketConnector = /*#__PURE__*/ function(SyncConnector) {
+    _inherits(YWebsocketConnector, SyncConnector);
+    function YWebsocketConnector(url, roomName, yDoc) {
+        _class_call_check$2(this, YWebsocketConnector);
+        var _this;
+        _this = _call_super(this, YWebsocketConnector), _define_property$2(_this, "provide", void 0), _define_property$2(_this, "onSync", function(is) {
+            if (is) {
+                _this.loadEvent.next();
+            }
+        }), _define_property$2(_this, "onUpdate", function() {
+            var syncStates = [];
+            _this.provide.awareness.getStates().forEach(function(state, id) {
+                syncStates.push({
+                    clientId: id,
+                    message: state.message
+                });
             });
-          });
-          this.actionStack.length = this.index;
-          this.changeEvent.next();
-        }
-        if (this.stackItem === null) {
-          this.stackItem = {
-            before: this.beforePosition,
-            after: null,
-            undoManagers: []
-          };
-          this.timer = setTimeout(() => {
-            if (this.actionStack.length >= this.stackSize) {
-              this.actionStack.shift();
-            } else {
-              this.index++;
-            }
-            this.stackItem.after = this.beforePosition;
-            this.actionStack.push(this.stackItem);
-            this.stackItem = null;
-            this.pushEvent.next();
-            this.changeEvent.next();
-          }, 500);
+            _this.stateChangeEvent.next(syncStates);
+        });
+        _this.onLoad = _this.loadEvent.asObservable();
+        _this.onStateChange = _this.stateChangeEvent.asObservable();
+        _this.provide = new WebsocketProvider(url, roomName, yDoc);
+        _this.provide.once('sync', _this.onSync);
+        _this.provide.awareness.on('update', _this.onUpdate);
+        return _this;
+    }
+    _create_class$2(YWebsocketConnector, [
+        {
+            key: "setLocalStateField",
+            value: function setLocalStateField(key, data) {
+                this.provide.awareness.setLocalStateField(key, data);
+            }
+        },
+        {
+            key: "onDestroy",
+            value: function onDestroy() {
+                this.provide.awareness.off('update', this.onUpdate);
+                this.provide.disconnect();
+                this.provide.destroy();
+            }
         }
-        this.stackItem.undoManagers.push(undoManager);
-      }
-    });
-    this.listenerCaches.add(undoManager);
-  }
-};
-MultipleDocCollabHistory = __decorateClass$1([
-  Injectable(),
-  __decorateParam(3, Inject(HISTORY_STACK_SIZE)),
-  __decorateParam(4, Optional())
-], MultipleDocCollabHistory);
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(result) || result;
-  return result;
-};
-const subModelLoaderErrorFn = makeError("subModelLoaderError");
-class SubModelLoader {
-}
-let NonSubModelLoader = class extends SubModelLoader {
-  createSubModelBySlot() {
-    throw subModelLoaderErrorFn("single document does not support async slot.");
-  }
-  createSubModelByComponent() {
-    throw subModelLoaderErrorFn("single document does not support async component.");
-  }
-  loadSubModelByComponent() {
-    throw subModelLoaderErrorFn("single document does not support async component.");
-  }
-  loadSubModelBySlot() {
-    throw subModelLoaderErrorFn("single document does not support async slot.");
-  }
-  getLoadedModelBySlot() {
-    throw subModelLoaderErrorFn("single document does not support async slot.");
-  }
-  getLoadedModelByComponent() {
-    throw subModelLoaderErrorFn("single document does not support async component.");
-  }
-};
-NonSubModelLoader = __decorateClass([
-  Injectable()
-], NonSubModelLoader);
-class SyncConnector {
-  /**
-   * 当文档加载完成时触发的观察者
-   */
-  onLoad;
-  /**
-   * 当文档 awareness 状态变更时触发的观察者
-   */
-  onStateChange;
-  loadEvent = new Subject();
-  stateChangeEvent = new Subject();
-  constructor() {
-    this.onLoad = this.loadEvent.asObservable();
-    this.onStateChange = this.stateChangeEvent.asObservable();
-  }
-}
-class HocuspocusConnector extends SyncConnector {
-  provide;
-  constructor(config) {
-    super();
-    this.provide = new HocuspocusProvider({
-      ...config,
-      onSynced: (data) => {
-        config.onSynced?.(data);
-        this.loadEvent.next();
-      },
-      onAwarenessUpdate: (data) => {
-        config.onAwarenessUpdate?.(data);
-        const states = data.states.map((state) => {
-          return {
-            clientId: state.clientId,
-            message: state.message
-          };
+    ]);
+    return YWebsocketConnector;
+}(SyncConnector);
+
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-        this.stateChangeEvent.next(states);
-      }
-    });
-  }
-  setLocalStateField(key, data) {
-    this.provide.setAwarenessField(key, data);
-  }
-  onDestroy() {
-    this.provide.disconnect();
-    this.provide.destroy();
-  }
-}
-class YWebsocketConnector extends SyncConnector {
-  provide;
-  onSync = (is) => {
-    if (is) {
-      this.loadEvent.next();
+    } else {
+        obj[key] = value;
     }
-  };
-  onUpdate = () => {
-    const syncStates = [];
-    this.provide.awareness.getStates().forEach((state, id) => {
-      syncStates.push({
-        clientId: id,
-        message: state.message
-      });
-    });
-    this.stateChangeEvent.next(syncStates);
-  };
-  constructor(url, roomName, yDoc) {
-    super();
-    this.onLoad = this.loadEvent.asObservable();
-    this.onStateChange = this.stateChangeEvent.asObservable();
-    this.provide = new WebsocketProvider(url, roomName, yDoc);
-    this.provide.once("sync", this.onSync);
-    this.provide.awareness.on("update", this.onUpdate);
-  }
-  setLocalStateField(key, data) {
-    this.provide.awareness.setLocalStateField(key, data);
-  }
-  onDestroy() {
-    this.provide.awareness.off("update", this.onUpdate);
-    this.provide.disconnect();
-    this.provide.destroy();
-  }
-}
-class CollaborateModule {
-  constructor(config) {
-    this.config = config;
-  }
-  config;
-  subscription = new Subscription();
-  providers = [
-    Collaborate,
-    CollabHistory,
-    {
-      provide: History,
-      useExisting: CollabHistory
-    },
-    {
-      provide: SyncConnector,
-      useFactory: (collab) => {
-        return this.config.createConnector(collab.yDoc);
-      },
-      deps: [Collaborate]
-    },
-    {
-      provide: SubModelLoader,
-      useClass: NonSubModelLoader
+    return obj;
+}
+var CollaborateModule = /*#__PURE__*/ function() {
+    function CollaborateModule(config) {
+        var _this = this;
+        _class_call_check$1(this, CollaborateModule);
+        _define_property$1(this, "config", void 0);
+        _define_property$1(this, "subscription", void 0);
+        _define_property$1(this, "providers", void 0);
+        _define_property$1(this, "timer", void 0);
+        this.config = config;
+        this.subscription = new Subscription();
+        this.providers = [
+            Collaborate,
+            CollabHistory,
+            {
+                provide: History,
+                useExisting: CollabHistory
+            },
+            {
+                provide: SyncConnector,
+                useFactory: function useFactory(collab) {
+                    return _this.config.createConnector(collab.yDoc);
+                },
+                deps: [
+                    Collaborate
+                ]
+            },
+            {
+                provide: SubModelLoader,
+                useClass: NonSubModelLoader
+            }
+        ];
+        this.timer = null;
     }
-  ];
-  timer = null;
-  setup(textbus) {
-    const messageBus = textbus.get(MessageBus, null);
-    const connector = textbus.get(SyncConnector);
-    const collab = textbus.get(Collaborate);
-    if (messageBus) {
-      const selection = textbus.get(Selection);
-      connector.setLocalStateField("message", messageBus.get(textbus));
-      this.subscription.add(
-        messageBus.onSync.subscribe(() => {
-          connector.setLocalStateField("message", messageBus.get(textbus));
-        }),
-        selection.onChange.subscribe(() => {
-          connector.setLocalStateField("message", messageBus.get(textbus));
-        }),
-        connector.onStateChange.subscribe((states) => {
-          messageBus.consume(states, textbus);
-        })
-      );
+    _create_class$1(CollaborateModule, [
+        {
+            key: "setup",
+            value: function setup(textbus) {
+                var _this = this;
+                var messageBus = textbus.get(MessageBus, null);
+                var connector = textbus.get(SyncConnector);
+                var collab = textbus.get(Collaborate);
+                if (messageBus) {
+                    var selection = textbus.get(Selection);
+                    connector.setLocalStateField('message', messageBus.get(textbus));
+                    this.subscription.add(messageBus.onSync.subscribe(function() {
+                        connector.setLocalStateField('message', messageBus.get(textbus));
+                    }), selection.onChange.subscribe(function() {
+                        connector.setLocalStateField('message', messageBus.get(textbus));
+                    }), connector.onStateChange.subscribe(function(states) {
+                        messageBus.consume(states, textbus);
+                    }));
+                }
+                return connector.onLoad.toPromise().then(function() {
+                    if (!_this.config.onlyLoad) {
+                        return;
+                    }
+                    var root = collab.yDoc.getMap('RootComponent');
+                    if (root.has('state')) {
+                        return;
+                    }
+                    return new Promise(function(resolve) {
+                        var testing = function testing1() {
+                            if (root.has('state')) {
+                                resolve();
+                            } else {
+                                _this.timer = setTimeout(testing, 1000);
+                            }
+                        };
+                        _this.timer = setTimeout(testing, 1000);
+                    });
+                });
+            }
+        },
+        {
+            key: "onDestroy",
+            value: function onDestroy(textbus) {
+                this.subscription.unsubscribe();
+                textbus.get(Collaborate).destroy();
+                textbus.get(History).destroy();
+                textbus.get(SyncConnector).onDestroy();
+                clearTimeout(this.timer);
+            }
+        }
+    ]);
+    return CollaborateModule;
+}();
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    return connector.onLoad.toPromise().then(() => {
-      if (!this.config.onlyLoad) {
-        return;
-      }
-      const root = collab.yDoc.getMap("RootComponent");
-      if (root.has("state")) {
-        return;
-      }
-      return new Promise((resolve) => {
-        const testing = () => {
-          if (root.has("state")) {
-            resolve();
-          } else {
-            this.timer = setTimeout(testing, 1e3);
-          }
-        };
-        this.timer = setTimeout(testing, 1e3);
-      });
-    });
-  }
-  onDestroy(textbus) {
-    this.subscription.unsubscribe();
-    textbus.get(Collaborate).destroy();
-    textbus.get(History).destroy();
-    textbus.get(SyncConnector).onDestroy();
-    clearTimeout(this.timer);
-  }
-}
-class MultipleDocumentCollaborateModule {
-  constructor(config) {
-    this.config = config;
-  }
-  config;
-  subscription = new Subscription();
-  providers = [
-    Collaborate,
-    MultipleDocCollabHistory,
-    {
-      provide: History,
-      useExisting: MultipleDocCollabHistory
-    },
-    {
-      provide: SyncConnector,
-      useFactory: (collab) => {
-        return this.config.createConnector(collab.yDoc);
-      },
-      deps: [Collaborate]
-    },
-    {
-      provide: SubModelLoader,
-      useFactory: () => {
-        return this.config.subModelLoader;
-      }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-  ];
-  timer = null;
-  setup(textbus) {
-    const messageBus = textbus.get(MessageBus, null);
-    const connector = textbus.get(SyncConnector);
-    const collab = textbus.get(Collaborate);
-    if (messageBus) {
-      const selection = textbus.get(Selection);
-      connector.setLocalStateField("message", messageBus.get(textbus));
-      this.subscription.add(
-        messageBus.onSync.subscribe(() => {
-          connector.setLocalStateField("message", messageBus.get(textbus));
-        }),
-        selection.onChange.subscribe(() => {
-          connector.setLocalStateField("message", messageBus.get(textbus));
-        }),
-        connector.onStateChange.subscribe((states) => {
-          messageBus.consume(states, textbus);
-        })
-      );
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-    return connector.onLoad.toPromise().then(() => {
-      if (!this.config.onlyLoad) {
-        return;
-      }
-      const root = collab.yDoc.getMap("RootComponent");
-      if (root.has("state")) {
-        return;
-      }
-      return new Promise((resolve) => {
-        const testing = () => {
-          if (root.has("state")) {
-            resolve();
-          } else {
-            this.timer = setTimeout(testing, 1e3);
-          }
-        };
-        this.timer = setTimeout(testing, 1e3);
-      });
-    });
-  }
-  onDestroy(textbus) {
-    this.subscription.unsubscribe();
-    textbus.get(Collaborate).destroy();
-    textbus.get(History).destroy();
-    textbus.get(SyncConnector).onDestroy();
-    clearTimeout(this.timer);
-  }
-}
-export {
-  CollabHistory,
-  Collaborate,
-  CollaborateModule,
-  CustomUndoManagerConfig,
-  HocuspocusConnector,
-  MessageBus,
-  MultipleDocCollabHistory,
-  MultipleDocumentCollaborateModule,
-  NonSubModelLoader,
-  SubModelLoader,
-  SyncConnector,
-  YWebsocketConnector
-};
+    return obj;
+}
+var MultipleDocumentCollaborateModule = /*#__PURE__*/ function() {
+    function MultipleDocumentCollaborateModule(config) {
+        var _this = this;
+        _class_call_check(this, MultipleDocumentCollaborateModule);
+        _define_property(this, "config", void 0);
+        _define_property(this, "subscription", void 0);
+        _define_property(this, "providers", void 0);
+        _define_property(this, "timer", void 0);
+        this.config = config;
+        this.subscription = new Subscription();
+        this.providers = [
+            Collaborate,
+            MultipleDocCollabHistory,
+            {
+                provide: History,
+                useExisting: MultipleDocCollabHistory
+            },
+            {
+                provide: SyncConnector,
+                useFactory: function useFactory(collab) {
+                    return _this.config.createConnector(collab.yDoc);
+                },
+                deps: [
+                    Collaborate
+                ]
+            },
+            {
+                provide: SubModelLoader,
+                useFactory: function useFactory() {
+                    return _this.config.subModelLoader;
+                }
+            }
+        ];
+        this.timer = null;
+    }
+    _create_class(MultipleDocumentCollaborateModule, [
+        {
+            key: "setup",
+            value: function setup(textbus) {
+                var _this = this;
+                var messageBus = textbus.get(MessageBus, null);
+                var connector = textbus.get(SyncConnector);
+                var collab = textbus.get(Collaborate);
+                if (messageBus) {
+                    var selection = textbus.get(Selection);
+                    connector.setLocalStateField('message', messageBus.get(textbus));
+                    this.subscription.add(messageBus.onSync.subscribe(function() {
+                        connector.setLocalStateField('message', messageBus.get(textbus));
+                    }), selection.onChange.subscribe(function() {
+                        connector.setLocalStateField('message', messageBus.get(textbus));
+                    }), connector.onStateChange.subscribe(function(states) {
+                        messageBus.consume(states, textbus);
+                    }));
+                }
+                return connector.onLoad.toPromise().then(function() {
+                    if (!_this.config.onlyLoad) {
+                        return;
+                    }
+                    var root = collab.yDoc.getMap('RootComponent');
+                    if (root.has('state')) {
+                        return;
+                    }
+                    return new Promise(function(resolve) {
+                        var testing = function testing1() {
+                            if (root.has('state')) {
+                                resolve();
+                            } else {
+                                _this.timer = setTimeout(testing, 1000);
+                            }
+                        };
+                        _this.timer = setTimeout(testing, 1000);
+                    });
+                });
+            }
+        },
+        {
+            key: "onDestroy",
+            value: function onDestroy(textbus) {
+                this.subscription.unsubscribe();
+                textbus.get(Collaborate).destroy();
+                textbus.get(History).destroy();
+                textbus.get(SyncConnector).onDestroy();
+                clearTimeout(this.timer);
+            }
+        }
+    ]);
+    return MultipleDocumentCollaborateModule;
+}();
+
+export { CollabHistory, Collaborate, CollaborateModule, CustomUndoManagerConfig, HocuspocusConnector, MessageBus, MultipleDocCollabHistory, MultipleDocumentCollaborateModule, NonSubModelLoader, SubModelLoader, SyncConnector, YWebsocketConnector };
 //# sourceMappingURL=index.esm.js.map