@textbus/collaborate 5.2.1 → 5.2.3

package/dist/index.esm.js

@@ -1,20 +1,32 @@
-import { Injectable as w, Inject as $, Optional as Y } from "@viewfly/core";
-import { makeError as x, HISTORY_STACK_SIZE as H, ChangeOrigin as q, Slot as m, observe as T, AsyncSlot as R, AsyncComponent as D, Component as N, History as L, Selection as j } from "@textbus/core";
-import { Subject as l, map as K, filter as Z, Subscription as _ } from "@tanbo/stream";
-import { UndoManager as b, Doc as G, createAbsolutePositionFromRelativePosition as P, createRelativePositionFromTypeIndex as O, Map as S, Array as F, Text as v } from "yjs";
-import { HocuspocusProvider as J } from "@hocuspocus/provider";
-import { WebsocketProvider as Q } from "y-websocket";
-var V = Object.getOwnPropertyDescriptor, X = (t, e, s, n) => {
-  for (var o = n > 1 ? void 0 : n ? V(e, s) : e, r = t.length - 1, a; r >= 0; r--)
-    (a = t[r]) && (o = a(o) || o);
-  return o;
-}, I = (t, e) => (s, n) => e(s, n, t);
-class pe {
+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 ee = x("CollabHistory");
-let E = class {
-  constructor(t, e, s, n, o) {
-    this.rootComponentRef = t, this.collaborate = e, this.scheduler = s, this.stackSize = n, this.undoManagerConfig = o, this.onBack = this.backEvent.asObservable(), this.onForward = this.forwardEvent.asObservable(), this.onChange = this.changeEvent.asObservable(), this.onPush = this.pushEvent.asObservable();
+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;
@@ -26,150 +38,234 @@ let E = class {
   onChange;
   onPush;
   get canBack() {
-    return this.manager?.canUndo() || !1;
+    return this.manager?.canUndo() || false;
   }
   get canForward() {
-    return this.manager?.canRedo() || !1;
+    return this.manager?.canRedo() || false;
   }
   manager = null;
   historyItems = [];
   index = 0;
   subscriptions = [];
-  backEvent = new l();
-  forwardEvent = new l();
-  changeEvent = new l();
-  pushEvent = new l();
+  backEvent = new Subject();
+  forwardEvent = new Subject();
+  changeEvent = new Subject();
+  pushEvent = new Subject();
   listen() {
-    const t = this.collaborate.yDoc.getMap("RootComponent"), e = this.rootComponentRef.component;
-    this.collaborate.syncRootComponent(this.collaborate.yDoc, t, e);
-    const s = this.undoManagerConfig || {}, n = new b(t, {
+    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(r) {
-        return s.captureTransaction ? s.captureTransaction(r) : !0;
+      captureTransaction(arg) {
+        if (undoManagerConfig.captureTransaction) {
+          return undoManagerConfig.captureTransaction(arg);
+        }
+        return true;
       },
-      deleteFilter(r) {
-        return s.deleteFilter ? s.deleteFilter(r) : !0;
+      deleteFilter(item) {
+        if (undoManagerConfig.deleteFilter) {
+          return undoManagerConfig.deleteFilter(item);
+        }
+        return true;
       }
     });
-    this.manager = n;
-    let o = null;
+    this.manager = manager;
+    let beforePosition = null;
     this.subscriptions.push(
       this.scheduler.onLocalChangeBefore.subscribe(() => {
-        o = this.collaborate.getRelativeCursorLocation();
+        beforePosition = this.collaborate.getRelativeCursorLocation();
       }),
       this.collaborate.onAddSubModel.subscribe(() => {
-        throw ee("single document does not support submodels.");
+        throw collabHistoryErrorFn("single document does not support submodels.");
       })
-    ), n.on("stack-item-added", (r) => {
-      r.type === "undo" ? r.origin === n ? this.index++ : (this.historyItems.length = this.index, this.historyItems.push({
-        before: o,
-        after: this.collaborate.getRelativeCursorLocation()
-      }), this.index++) : this.index--, n.undoStack.length > this.stackSize && (this.historyItems.shift(), n.undoStack.shift()), r.origin === this.collaborate.yDoc && this.pushEvent.next(), this.changeEvent.next();
-    }), n.on("stack-item-popped", (r) => {
-      const a = r.type === "undo" ? this.index : this.index - 1, i = this.historyItems[a] || null, c = r.type === "undo" ? i?.before : i?.after;
-      this.collaborate.restoreCursorPosition(c);
+    );
+    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() {
-    this.canBack && (this.manager?.undo(), this.backEvent.next());
+    if (this.canBack) {
+      this.manager?.undo();
+      this.backEvent.next();
+    }
   }
   forward() {
-    this.canForward && (this.manager?.redo(), this.forwardEvent.next());
+    if (this.canForward) {
+      this.manager?.redo();
+      this.forwardEvent.next();
+    }
   }
   clear() {
-    const t = this.historyItems.pop();
-    this.historyItems = t ? [t] : [], this.index = t ? 1 : 0, this.manager?.clear(), this.changeEvent.next();
+    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((t) => t.unsubscribe()), this.manager && (this.manager.destroy(), this.manager.captureTransaction = () => !0, this.manager.deleteFilter = () => !0, this.manager.trackedOrigins = /* @__PURE__ */ new Set([null])), this.manager = null;
+    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]);
+    }
+    this.manager = null;
   }
 };
-E = X([
-  w(),
-  I(3, $(H)),
-  I(4, Y())
-], E);
-var te = Object.getOwnPropertyDescriptor, se = (t, e, s, n) => {
-  for (var o = n > 1 ? void 0 : n ? te(e, s) : e, r = t.length - 1, a; r >= 0; r--)
-    (a = t[r]) && (o = a(o) || o);
-  return o;
+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 g = x("Collaborate");
-class ne {
+const collaborateErrorFn = makeError("Collaborate");
+class SlotMap {
   slotAndYTextMap = /* @__PURE__ */ new WeakMap();
   yTextAndSlotMap = /* @__PURE__ */ new WeakMap();
-  set(e, s) {
-    e instanceof m ? (this.slotAndYTextMap.set(e, s), this.yTextAndSlotMap.set(s, e)) : (this.slotAndYTextMap.set(s, e), this.yTextAndSlotMap.set(e, s));
-  }
-  get(e) {
-    return e instanceof m ? this.slotAndYTextMap.get(e) || null : this.yTextAndSlotMap.get(e) || null;
+  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);
+    }
   }
-  delete(e) {
-    if (e instanceof m) {
-      const s = this.slotAndYTextMap.get(e);
-      this.slotAndYTextMap.delete(e), s && this.yTextAndSlotMap.delete(s);
+  get(key) {
+    if (key instanceof Slot) {
+      return this.slotAndYTextMap.get(key) || null;
+    }
+    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 s = this.yTextAndSlotMap.get(e);
-      this.yTextAndSlotMap.delete(e), s && this.slotAndYTextMap.delete(s);
+      const v = this.yTextAndSlotMap.get(key);
+      this.yTextAndSlotMap.delete(key);
+      if (v) {
+        this.slotAndYTextMap.delete(v);
+      }
     }
   }
 }
-let f = class {
-  constructor(t, e, s, n) {
-    this.scheduler = t, this.registry = e, this.selection = s, this.subModelLoader = n, this.onAddSubModel = this.addSubModelEvent.asObservable();
+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 G();
-  slotMap = new ne();
+  yDoc = new Doc();
+  slotMap = new SlotMap();
   onAddSubModel;
   subscriptions = [];
-  updateFromRemote = !1;
-  addSubModelEvent = new l();
+  updateFromRemote = false;
+  addSubModelEvent = new Subject();
   updateRemoteActions = /* @__PURE__ */ new WeakMap();
   noRecord = {};
-  syncRootComponent(t, e, s) {
-    this.initSyncEvent(t), this.syncComponent(t, e, s);
-  }
-  syncRootSlot(t, e, s) {
-    e.length ? (s.retain(0), s.delete(s.length), s.cleanAttributes(), s.cleanFormats(), this.initLocalSlotBySharedSlot(e, s)) : t.transact(() => {
-      this.initSharedSlotByLocalSlot(e, s);
-    }), this.initSyncEvent(t), this.syncSlot(e, s);
-  }
-  getAbstractSelection(t) {
-    const e = P(t.anchor.position, t.anchor.doc), s = P(t.focus.position, t.focus.doc);
-    if (e && s) {
-      const n = this.slotMap.get(s.type), o = this.slotMap.get(e.type);
-      if (n && o)
+  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);
+      });
+    }
+    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: o,
-          anchorOffset: e.index,
-          focusSlot: n,
-          focusOffset: s.index
+          anchorSlot,
+          anchorOffset: anchorPosition.index,
+          focusSlot,
+          focusOffset: focusPosition.index
         };
+      }
     }
     return null;
   }
   getRelativeCursorLocation() {
-    const { anchorSlot: t, anchorOffset: e, focusSlot: s, focusOffset: n } = this.selection;
-    if (t) {
-      const o = this.slotMap.get(t);
-      if (o) {
-        const r = O(o, e);
-        if (s) {
-          const a = this.slotMap.get(s);
-          if (a) {
-            const i = O(a, n);
+    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: a.doc,
-                position: i
+                doc: focusYText.doc,
+                position: focusPosition
               },
               anchor: {
-                doc: o.doc,
-                position: r
+                doc: anchorYText.doc,
+                position: anchorPosition
               }
             };
           }
@@ -178,315 +274,494 @@ let f = class {
     }
     return null;
   }
-  restoreCursorPosition(t) {
-    if (!t) {
+  restoreCursorPosition(position) {
+    if (!position) {
       this.selection.unSelect();
       return;
     }
-    const e = this.getAbstractSelection(t);
-    e && this.selection.setBaseAndExtent(
-      e.anchorSlot,
-      e.anchorOffset,
-      e.focusSlot,
-      e.focusOffset
-    );
+    const selection = this.getAbstractSelection(position);
+    if (selection) {
+      this.selection.setBaseAndExtent(
+        selection.anchorSlot,
+        selection.anchorOffset,
+        selection.focusSlot,
+        selection.focusOffset
+      );
+    }
   }
-  initSyncEvent(t) {
+  initSyncEvent(yDoc) {
     this.subscriptions.push(
       this.scheduler.onDocChanged.pipe(
-        K((e) => e.filter((s) => s.from !== q.Remote)),
-        Z((e) => e.length)
+        map((item) => {
+          return item.filter((i) => {
+            return i.from !== ChangeOrigin.Remote;
+          });
+        }),
+        filter((item) => {
+          return item.length;
+        })
       ).subscribe(() => {
-        const e = [];
-        let s = null;
-        const n = this.updateRemoteActions.get(t) || [];
-        for (const o of n)
-          s || (s = {
-            record: o.record,
-            actions: []
-          }, e.push(s)), s.record === o.record ? s.actions.push(o.action) : (s = {
-            record: o.record,
-            actions: [o.action]
-          }, e.push(s));
-        this.updateRemoteActions.delete(t);
-        for (const o of e)
-          t.transact(() => {
-            o.actions.forEach((r) => {
-              r();
+        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);
+          }
+        }
+        this.updateRemoteActions.delete(yDoc);
+        for (const item of updates) {
+          yDoc.transact(() => {
+            item.actions.forEach((fn) => {
+              fn();
             });
-          }, o.record ? t : this.noRecord);
+          }, item.record ? yDoc : this.noRecord);
+        }
       })
     );
   }
-  syncComponent(t, e, s) {
-    let n = e.get("state");
-    n ? (Object.keys(s.state).forEach((o) => {
-      Reflect.deleteProperty(s.state, o);
-    }), this.syncSharedMapToLocalMap(n, s.state)) : (n = new S(), this.syncLocalMapToSharedMap(s.state, n), t.transact(() => {
-      e.set("state", n);
-    }));
-  }
-  syncSlot(t, e) {
-    const s = (o, r) => {
-      this.runRemoteUpdate(r, () => {
-        e.retain(0), o.keysChanged.forEach((a) => {
-          const i = o.keys.get(a);
-          if (!i)
+  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 c = i.action;
-          if (c === "update" || c === "add") {
-            const h = this.registry.getAttribute(a);
-            h && e.setAttribute(h, t.getAttribute(a));
-          } else if (c === "delete") {
-            const h = this.registry.getAttribute(a);
-            h && e.removeAttribute(h);
           }
-        }), o.delta.forEach((a) => {
-          if (Reflect.has(a, "retain")) {
-            if (a.attributes) {
-              const i = C(this.registry, a.attributes);
-              i.length && e.retain(a.retain, i);
+          const updateType = change.action;
+          if (updateType === "update" || updateType === "add") {
+            const attribute = this.registry.getAttribute(key);
+            if (attribute) {
+              localSlot.setAttribute(attribute, sharedSlot.getAttribute(key));
             }
-            e.retain(e.index + a.retain);
-          } else if (a.insert) {
-            const i = e.index;
-            let c = 1;
-            if (typeof a.insert == "string")
-              c = a.insert.length, e.insert(a.insert, C(this.registry, a.attributes));
-            else {
-              const h = a.insert, d = this.createLocalComponentBySharedComponent(h);
-              e.insert(d);
+          } 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);
+              }
             }
-            this.selection.isSelected && !(r.origin instanceof b) && (e === this.selection.anchorSlot && this.selection.anchorOffset > i && this.selection.setAnchor(e, this.selection.anchorOffset + c), e === this.selection.focusSlot && this.selection.focusOffset > i && this.selection.setFocus(e, this.selection.focusOffset + c));
-          } else if (a.delete) {
-            const i = e.index;
-            e.delete(a.delete), this.selection.isSelected && !(r.origin instanceof b) && (e === this.selection.anchorSlot && this.selection.anchorOffset >= i && this.selection.setAnchor(e, this.selection.startOffset - a.delete), e === this.selection.focusSlot && this.selection.focusOffset >= i && this.selection.setFocus(e, this.selection.focusOffset - a.delete));
           }
         });
       });
     };
-    t.observe(s);
-    const n = e.onContentChange.subscribe((o) => {
-      this.runLocalUpdate(t.doc, !0, () => {
-        let r = 0, a = 0;
-        for (const i of o)
-          if (i.type === "retain") {
-            const c = i.formats;
-            if (c) {
-              const h = Object.keys(c);
-              let d = h.length;
-              h.forEach((u) => {
-                this.registry.getFormatter(u) || (d--, Reflect.deleteProperty(c, u));
-              }), d && t.format(r, i.offset, c);
-            } else
-              r = i.offset;
-          } else if (i.type === "contentInsert") {
-            const c = t.toDelta(), h = c.length === 1 && c[0].insert === m.emptyPlaceholder;
-            if (typeof i.content == "string")
-              a = i.content.length, t.insert(r, i.content, i.formats || {});
-            else {
-              a = 1;
-              const d = this.createSharedComponentByLocalComponent(i.ref);
-              t.insertEmbed(r, d, i.formats || {});
+    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);
+                }
+              });
+              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);
             }
-            h && r === 0 && t.delete(t.length - 1, 1), r += a;
-          } else if (i.type === "delete") {
-            const c = t.toDelta();
-            t.length && t.delete(r, i.count), t.length === 0 && t.insert(0, `
-`, c[0]?.attributes);
-          } else i.type === "attrSet" ? t.setAttribute(i.name, i.value) : i.type === "attrDelete" && t.removeAttribute(i.name);
+            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(e, t), e.__changeMarker__.addDetachCallback(() => {
-      this.slotMap.delete(e), t.unobserve(s), n.unsubscribe();
+    this.slotMap.set(localSlot, sharedSlot);
+    localSlot.__changeMarker__.addDetachCallback(() => {
+      this.slotMap.delete(localSlot);
+      sharedSlot.unobserve(syncRemote);
+      sub.unsubscribe();
     });
   }
   destroy() {
-    this.subscriptions.forEach((t) => t.unsubscribe()), this.subscriptions = [];
-  }
-  syncSharedMapToLocalMap(t, e) {
-    t.forEach((s, n) => {
-      e[n] = this.createLocalModelBySharedByModel(s);
-    }), this.syncObject(t, e);
-  }
-  createLocalMapBySharedMap(t) {
-    const e = T({});
-    return this.syncSharedMapToLocalMap(t, e), e;
-  }
-  createLocalArrayBySharedArray(t) {
-    const e = T([]);
-    return e.push(...t.map((s) => this.createLocalModelBySharedByModel(s))), this.syncArray(t, e), e;
-  }
-  syncLocalMapToSharedMap(t, e) {
-    Object.entries(t).forEach(([s, n]) => {
-      e.set(s, this.createSharedModelByLocalModel(n));
-    }), this.syncObject(e, t);
-  }
-  createSharedMapByLocalMap(t) {
-    const e = new S();
-    return this.syncLocalMapToSharedMap(t, e), e;
-  }
-  createSharedArrayByLocalArray(t) {
-    const e = new F();
-    return t.forEach((s) => {
-      e.push([this.createSharedModelByLocalModel(s)]);
-    }), this.syncArray(e, t), e;
-  }
-  createSharedSlotByLocalSlot(t) {
-    const e = new v(), s = t instanceof R;
-    if (e.setAttribute("schema", [...t.schema]), e.setAttribute("type", s ? "async" : "sync"), s) {
-      let r = !1;
-      const a = this.createSharedMapByLocalMap(t.metadata);
-      return e.setAttribute("metadata", a), this.subModelLoader.createSubModelBySlot(t).then((i) => {
-        if (r)
+    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;
-        const c = i.getText("content"), h = i.getMap("state");
-        this.syncLocalMapToSharedMap(t.state, h), this.initSharedSlotByLocalSlot(c, t), this.syncSlot(c, t), this.addSubModelEvent.next({
-          yDoc: i,
-          yType: c
-        }), this.initSyncEvent(i), t.loader.markAsLoaded();
-      }), t.__changeMarker__.addDetachCallback(() => {
-        r = !0;
-      }), e;
-    }
-    const n = new S();
-    this.syncLocalMapToSharedMap(t.state, n), e.setAttribute("state", n);
-    const o = new v();
-    return this.initSharedSlotByLocalSlot(o, t), e.insertEmbed(0, o), this.syncSlot(o, t), e;
-  }
-  initSharedSlotByLocalSlot(t, e) {
-    let s = 0;
-    e.toDelta().forEach((n) => {
-      let o = {};
-      if (n.formats ? n.formats.forEach((r) => {
-        o[r[0].name] = r[1];
-      }) : o = null, typeof n.insert == "string")
-        t.insert(s, n.insert, o);
-      else {
-        const r = this.createSharedComponentByLocalComponent(n.insert);
-        t.insertEmbed(s, r, o);
+        }
+        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;
+    }
+    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);
       }
-      s += n.insert.length;
-    }), e.getAttributes().forEach((n) => {
-      t.setAttribute(n[0].name, n[1]);
+      offset += i.insert.length;
+    });
+    localSlot.getAttributes().forEach((item) => {
+      sharedContent.setAttribute(item[0].name, item[1]);
     });
   }
-  createLocalSlotBySharedSlot(t) {
-    const e = t.getAttribute("type"), s = t.getAttribute("schema");
-    if (e === "async") {
-      const i = t.getAttribute("metadata"), c = new R(s || [], {}, {});
-      this.syncSharedMapToLocalMap(i, c.metadata);
-      const h = this.subModelLoader.getLoadedModelBySlot(c);
-      if (h) {
-        const u = h.getText("content"), M = h.getMap("state");
-        return this.syncSharedMapToLocalMap(M, c.state), this.syncRootSlot(h, u, c), this.addSubModelEvent.next({
-          yDoc: h,
-          yType: u
-        }), c.loader.markAsLoaded(), c;
+  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 d = !1;
-      return c.loader.onRequestLoad.toPromise().then(() => this.subModelLoader.loadSubModelBySlot(c)).then((u) => {
-        if (d)
+      let isDestroyed = false;
+      slot.loader.onRequestLoad.toPromise().then(() => {
+        return this.subModelLoader.loadSubModelBySlot(slot);
+      }).then((subDocument) => {
+        if (isDestroyed) {
           return;
-        const M = u.getText("content"), W = u.getMap("state");
-        this.syncSharedMapToLocalMap(W, c.state), this.syncRootSlot(u, M, c), this.addSubModelEvent.next({
-          yDoc: u,
-          yType: M
-        }), c.loader.markAsLoaded();
-      }), c.__changeMarker__.addDetachCallback(() => {
-        d = !0;
-      }), c;
-    }
-    const o = t.toDelta()[0]?.insert;
-    if (!(o instanceof v))
-      throw g("shared slot content type is not `YText`.");
-    const r = new m(s || [], {}), a = t.getAttribute("state");
-    return this.syncSharedMapToLocalMap(a, r.state), this.initLocalSlotBySharedSlot(o, r), this.syncSlot(o, r), r;
-  }
-  initLocalSlotBySharedSlot(t, e) {
-    const s = t.toDelta(), n = t.getAttributes();
-    Object.keys(n).forEach((o) => {
-      const r = this.registry.getAttribute(o);
-      r && e.setAttribute(r, n[o]);
+        }
+        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
+        });
+        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`.");
+    }
+    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 o of s)
-      if (o.insert)
-        if (typeof o.insert == "string") {
-          const r = C(this.registry, o.attributes);
-          e.insert(o.insert, r);
+    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 r = o.insert, a = this.createLocalComponentBySharedComponent(r);
-          e.insert(a, C(this.registry, o.attributes));
+          const sharedComponent = action.insert;
+          const component = this.createLocalComponentBySharedComponent(sharedComponent);
+          localSlot.insert(component, remoteFormatsToLocal(this.registry, action.attributes));
         }
-      else
-        throw g("unexpected delta action.");
-  }
-  createSharedModelByLocalModel(t) {
-    return t instanceof m ? this.createSharedSlotByLocalSlot(t) : Array.isArray(t) ? this.createSharedArrayByLocalArray(t) : typeof t == "object" && t !== null ? this.createSharedMapByLocalMap(t) : t;
-  }
-  createLocalModelBySharedByModel(t) {
-    return t instanceof S ? this.createLocalMapBySharedMap(t) : t instanceof F ? this.createLocalArrayBySharedArray(t) : t instanceof v ? this.createLocalSlotBySharedSlot(t) : t;
-  }
-  createSharedComponentByLocalComponent(t) {
-    const e = new S();
-    if (e.set("name", t.name), t instanceof D) {
-      e.set("type", "async");
-      const n = this.createSharedMapByLocalMap(t.metadata);
-      e.set("metadata", n);
-      const o = t.state;
-      let r = !1;
-      return o.__changeMarker__.addDetachCallback(() => {
-        r = !0;
-      }), this.subModelLoader.createSubModelByComponent(t).then((a) => {
-        if (r)
+      } else {
+        throw collaborateErrorFn("unexpected delta action.");
+      }
+    }
+  }
+  createSharedModelByLocalModel(localModel) {
+    if (localModel instanceof Slot) {
+      return this.createSharedSlotByLocalSlot(localModel);
+    }
+    if (Array.isArray(localModel)) {
+      return this.createSharedArrayByLocalArray(localModel);
+    }
+    if (typeof localModel === "object" && localModel !== null) {
+      return this.createSharedMapByLocalMap(localModel);
+    }
+    return localModel;
+  }
+  createLocalModelBySharedByModel(sharedModel) {
+    if (sharedModel instanceof Map) {
+      return this.createLocalMapBySharedMap(sharedModel);
+    }
+    if (sharedModel instanceof Array$1) {
+      return this.createLocalArrayBySharedArray(sharedModel);
+    }
+    if (sharedModel instanceof Text) {
+      return this.createLocalSlotBySharedSlot(sharedModel);
+    }
+    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;
-        const i = a.getMap("state");
-        this.syncComponent(a, i, t), this.addSubModelEvent.next({
-          yType: i,
-          yDoc: a
-        }), this.initSyncEvent(a), t.loader.markAsLoaded();
-      }), e;
-    }
-    const s = this.createSharedMapByLocalMap(t.state);
-    return e.set("state", s), e.set("type", "sync"), e;
-  }
-  createLocalComponentBySharedComponent(t) {
-    const e = t.get("name"), s = t.get("type");
-    let n;
-    if (s === "async") {
-      if (n = this.registry.createComponentByData(e, {}, {}), n instanceof D) {
-        const o = t.get("metadata");
-        this.syncSharedMapToLocalMap(o, n.metadata);
-        const r = this.subModelLoader.getLoadedModelByComponent(n);
-        if (r) {
-          const c = r.getMap("state");
-          return this.syncComponent(r, c, n), this.addSubModelEvent.next({
-            yType: c,
-            yDoc: r
-          }), n.loader.markAsLoaded(), n;
         }
-        const a = n.state;
-        let i = !1;
-        n.loader.onRequestLoad.toPromise().then(() => this.subModelLoader.loadSubModelByComponent(n)).then((c) => {
-          if (i)
+        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;
+    }
+    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 h = c.getMap("state");
-          this.syncComponent(c, h, n), this.addSubModelEvent.next({
-            yType: h,
-            yDoc: c
-          }), n.loader.markAsLoaded();
-        }), a.__changeMarker__.addDetachCallback(() => {
-          i = !0;
+          }
+          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;
         });
-      } else if (n instanceof N)
-        throw g(`component name \`${e}\` is not a async component.`);
+      } else if (instance instanceof Component) {
+        throw collaborateErrorFn(`component name \`${componentName}\` is not a async component.`);
+      }
     } else {
-      const o = t.get("state"), r = this.createLocalMapBySharedMap(o);
-      n = this.registry.createComponentByData(e, r);
+      const sharedState = yMap.get("state");
+      const state = this.createLocalMapBySharedMap(sharedState);
+      instance = this.registry.createComponentByData(componentName, state);
     }
-    if (n)
-      return n;
-    throw g(`cannot find component factory \`${e}\`.`);
+    if (instance) {
+      return instance;
+    }
+    throw collaborateErrorFn(`cannot find component factory \`${componentName}\`.`);
   }
   /**
    * 双向同步数组
@@ -494,52 +769,80 @@ let f = class {
    * @param localArray
    * @private
    */
-  syncArray(t, e) {
-    function s(r) {
-      console.error(g(`${r} error, length exceeded, path in ${e.__changeMarker__.getPaths().join("/")}`));
-    }
-    const n = e.__changeMarker__.onSelfChange.subscribe((r) => {
-      this.runLocalUpdate(t.doc, !e.__changeMarker__.irrevocableUpdate, () => {
-        let a = 0;
-        for (const i of r)
-          switch (i.type) {
+  syncArray(sharedArray, localArray) {
+    function logError(type) {
+      console.error(collaborateErrorFn(`${type} error, length exceeded, path in ${localArray.__changeMarker__.getPaths().join("/")}`));
+    }
+    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":
-              a = i.offset;
+              index = action.offset;
               break;
             case "insert":
               {
-                const c = i.ref;
-                if (!Array.isArray(c))
-                  throw g("The insertion action must have a reference value.");
-                const h = c.map((d) => this.createSharedModelByLocalModel(d));
-                a <= t.length ? t.insert(a, h) : (t.insert(t.length, h), s("insert"));
+                const ref = action.ref;
+                if (!Array.isArray(ref)) {
+                  throw collaborateErrorFn("The insertion action must have a reference value.");
+                }
+                const data = ref.map((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 (i.count <= 0)
+              if (action.count <= 0) {
                 break;
-              a < t.length ? t.delete(a, i.count) : s("delete");
+              }
+              if (index < sharedArray.length) {
+                sharedArray.delete(index, action.count);
+              } else {
+                logError("delete");
+              }
               break;
             case "setIndex":
-              i.index < t.length ? (t.delete(i.index, 1), t.insert(i.index, [this.createSharedModelByLocalModel(i.ref)])) : (t.insert(t.length, [this.createSharedModelByLocalModel(i.ref)]), s("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;
           }
+        }
       });
-    }), o = (r, a) => {
-      this.runRemoteUpdate(a, () => {
-        let i = 0;
-        r.delta.forEach((c) => {
-          if (Reflect.has(c, "retain"))
-            i += c.retain;
-          else if (c.insert) {
-            const h = c.insert.map((d) => this.createLocalModelBySharedByModel(d));
-            e.splice(i, 0, ...h), i += h.length;
-          } else c.delete && e.splice(i, c.delete);
+    });
+    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);
+          }
         });
       });
     };
-    t.observe(o), e.__changeMarker__.addDetachCallback(() => {
-      n.unsubscribe(), t.unobserve(o);
+    sharedArray.observe(syncRemote);
+    localArray.__changeMarker__.addDetachCallback(() => {
+      sub.unsubscribe();
+      sharedArray.unobserve(syncRemote);
     });
   }
   /**
@@ -548,65 +851,90 @@ let f = class {
    * @param localObject
    * @private
    */
-  syncObject(t, e) {
-    const s = (o, r) => {
-      this.runRemoteUpdate(r, () => {
-        o.changes.keys.forEach((a, i) => {
-          if (a.action === "add" || a.action === "update") {
-            const c = t.get(i);
-            e[i] = this.createLocalModelBySharedByModel(c);
-          } else
-            Reflect.deleteProperty(e, i);
+  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);
+          }
         });
       });
     };
-    t.observe(s);
-    const n = e.__changeMarker__.onSelfChange.subscribe((o) => {
-      this.runLocalUpdate(t.doc, !e.__changeMarker__.irrevocableUpdate, () => {
-        for (const r of o)
-          switch (r.type) {
+    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 a = this.createSharedModelByLocalModel(r.ref);
-                t.set(r.key, a), t.size === 0 && console.error(g(`prop set error, key is ${r.key}`));
+                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":
-              t.delete(r.key);
+              sharedObject.delete(action.key);
               break;
           }
+        }
       });
     });
-    e.__changeMarker__.addDetachCallback(function() {
-      t.unobserve(s), n.unsubscribe();
+    localObject.__changeMarker__.addDetachCallback(function() {
+      sharedObject.unobserve(syncRemote);
+      sub.unsubscribe();
     });
   }
-  runLocalUpdate(t, e, s) {
-    if (this.updateFromRemote || !t)
+  runLocalUpdate(yDoc, record, fn) {
+    if (this.updateFromRemote || !yDoc) {
       return;
-    let n = this.updateRemoteActions.get(t);
-    n || (n = [], this.updateRemoteActions.set(t, n)), n.push({
-      record: e,
-      action: s
+    }
+    let changeList = this.updateRemoteActions.get(yDoc);
+    if (!changeList) {
+      changeList = [];
+      this.updateRemoteActions.set(yDoc, changeList);
+    }
+    changeList.push({
+      record,
+      action: fn
     });
   }
-  runRemoteUpdate(t, e) {
-    t.origin !== t.doc && (this.updateFromRemote = !0, t.origin instanceof b ? this.scheduler.historyApplyTransact(e) : this.scheduler.remoteUpdateTransact(e), this.updateFromRemote = !1);
+  runRemoteUpdate(tr, fn) {
+    if (tr.origin === tr.doc) {
+      return;
+    }
+    this.updateFromRemote = true;
+    if (tr.origin instanceof UndoManager) {
+      this.scheduler.historyApplyTransact(fn);
+    } else {
+      this.scheduler.remoteUpdateTransact(fn);
+    }
+    this.updateFromRemote = false;
   }
 };
-f = se([
-  w()
-], f);
-function C(t, e) {
-  const s = [];
-  return e && Object.keys(e).forEach((n) => {
-    const o = t.getFormatter(n);
-    o && s.push([o, e[n]]);
-  }), s;
+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 z {
+class MessageBus {
   onSync;
-  syncEvent = new l();
+  syncEvent = new Subject();
   constructor() {
     this.onSync = this.syncEvent.asObservable();
   }
@@ -617,14 +945,26 @@ class z {
     this.syncEvent.next();
   }
 }
-var oe = Object.getOwnPropertyDescriptor, re = (t, e, s, n) => {
-  for (var o = n > 1 ? void 0 : n ? oe(e, s) : e, r = t.length - 1, a; r >= 0; r--)
-    (a = t[r]) && (o = a(o) || o);
-  return o;
-}, U = (t, e) => (s, n) => e(s, n, t);
-let k = class {
-  constructor(t, e, s, n, o) {
-    this.collaborate = t, this.scheduler = e, this.rootComponentRef = s, this.stackSize = n, this.undoManagerConfig = o, this.onChange = this.changeEvent.asObservable(), this.onBack = this.backEvent.asObservable(), this.onForward = this.forwardEvent.asObservable(), this.onPush = this.pushEvent.asObservable();
+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;
@@ -641,25 +981,34 @@ let k = class {
   get canForward() {
     return this.actionStack.length > 0 && this.index < this.actionStack.length;
   }
-  isListen = !1;
-  changeEvent = new l();
-  backEvent = new l();
-  forwardEvent = new l();
-  pushEvent = new l();
+  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 = new Subscription();
   subDocs = /* @__PURE__ */ new Set();
   listenerCaches = /* @__PURE__ */ new Set();
   listen() {
-    this.isListen = !0;
-    const t = this.collaborate.yDoc.getMap("RootComponent"), e = this.rootComponentRef.component;
-    this.collaborate.syncRootComponent(this.collaborate.yDoc, t, e), this.listenItem(t, this.collaborate.yDoc), this.subscription.add(
-      this.collaborate.onAddSubModel.subscribe(({ yType: s, yDoc: n }) => {
-        this.subDocs.has(s) || (this.subDocs.add(s), this.isListen && this.listenItem(s, n));
+    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);
+        }
       }),
       this.scheduler.onLocalChangeBefore.subscribe(() => {
         this.beforePosition = this.collaborate.getRelativeCursorLocation();
@@ -667,104 +1016,162 @@ let k = class {
     );
   }
   forward() {
-    if (!this.canForward)
+    if (!this.canForward) {
       return;
+    }
     clearTimeout(this.timer);
-    const t = this.actionStack[this.index];
-    if (t) {
-      for (const e of t.undoManagers)
-        e.redo();
-      this.collaborate.restoreCursorPosition(t.after);
+    const item = this.actionStack[this.index];
+    if (item) {
+      for (const i of item.undoManagers) {
+        i.redo();
+      }
+      this.collaborate.restoreCursorPosition(item.after);
     }
-    this.index++, this.forwardEvent.next(), this.changeEvent.next();
+    this.index++;
+    this.forwardEvent.next();
+    this.changeEvent.next();
   }
   back() {
-    if (!this.canBack)
+    if (!this.canBack) {
       return;
+    }
     clearTimeout(this.timer);
-    let t;
-    this.stackItem ? (t = this.stackItem, this.stackItem = null) : (this.index--, t = this.actionStack[this.index]);
-    let e = t.undoManagers.length;
-    for (; e > 0; )
-      e--, t.undoManagers[e].undo();
-    if (t) {
-      const s = t.before;
-      this.collaborate.restoreCursorPosition(s), this.backEvent.next(), this.changeEvent.next();
+    let historyStackItem;
+    if (this.stackItem) {
+      historyStackItem = this.stackItem;
+      this.stackItem = null;
+    } else {
+      this.index--;
+      historyStackItem = this.actionStack[this.index];
+    }
+    let len = historyStackItem.undoManagers.length;
+    while (len > 0) {
+      len--;
+      historyStackItem.undoManagers[len].undo();
+    }
+    if (historyStackItem) {
+      const beforePosition = historyStackItem.before;
+      this.collaborate.restoreCursorPosition(beforePosition);
+      this.backEvent.next();
+      this.changeEvent.next();
     }
   }
   clear() {
-    this.actionStack = [], this.stackItem = null, this.index = 0, this.beforePosition = null, clearTimeout(this.timer), this.listenerCaches.forEach((t) => {
-      t.clear();
-    }), this.changeEvent.next();
+    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((t) => {
-      t.destroy();
-    }), this.subDocs.clear(), this.listenerCaches.clear();
+    this.clear();
+    this.beforePosition = this.stackItem = null;
+    this.subscription.unsubscribe();
+    this.listenerCaches.forEach((undoManager) => {
+      undoManager.destroy();
+    });
+    this.subDocs.clear();
+    this.listenerCaches.clear();
   }
-  listenItem(t, e) {
-    const s = this.undoManagerConfig || {}, n = new b(t, {
-      trackedOrigins: /* @__PURE__ */ new Set([e]),
+  listenItem(yType, yDoc) {
+    const undoManagerConfig = this.undoManagerConfig || {};
+    const undoManager = new UndoManager(yType, {
+      trackedOrigins: /* @__PURE__ */ new Set([yDoc]),
       captureTimeout: 0,
-      captureTransaction(o) {
-        return s.captureTransaction ? s.captureTransaction(o) : !0;
+      captureTransaction(arg) {
+        if (undoManagerConfig.captureTransaction) {
+          return undoManagerConfig.captureTransaction(arg);
+        }
+        return true;
       },
-      deleteFilter(o) {
-        return s.deleteFilter ? s.deleteFilter(o) : !0;
+      deleteFilter(item) {
+        if (undoManagerConfig.deleteFilter) {
+          return undoManagerConfig.deleteFilter(item);
+        }
+        return true;
       }
     });
-    n.on("stack-item-added", (o) => {
-      o.type === "undo" && !(o.origin instanceof b) && (this.index != this.actionStack.length && (this.actionStack.slice(this.index).forEach((a) => {
-        a.undoManagers.forEach((i) => {
-          i.clear(!1, !0);
-        });
-      }), this.actionStack.length = this.index, this.changeEvent.next()), this.stackItem === null && (this.stackItem = {
-        before: this.beforePosition,
-        after: null,
-        undoManagers: []
-      }, this.timer = setTimeout(() => {
-        this.actionStack.length >= this.stackSize ? this.actionStack.shift() : this.index++, this.stackItem.after = this.beforePosition, this.actionStack.push(this.stackItem), this.stackItem = null, this.pushEvent.next(), this.changeEvent.next();
-      }, 500)), this.stackItem.undoManagers.push(n));
-    }), this.listenerCaches.add(n);
+    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);
+            });
+          });
+          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.stackItem.undoManagers.push(undoManager);
+      }
+    });
+    this.listenerCaches.add(undoManager);
   }
 };
-k = re([
-  w(),
-  U(3, $(H)),
-  U(4, Y())
-], k);
-var ae = Object.getOwnPropertyDescriptor, ie = (t, e, s, n) => {
-  for (var o = n > 1 ? void 0 : n ? ae(e, s) : e, r = t.length - 1, a; r >= 0; r--)
-    (a = t[r]) && (o = a(o) || o);
-  return o;
+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 y = x("subModelLoaderError");
-class A {
+const subModelLoaderErrorFn = makeError("subModelLoaderError");
+class SubModelLoader {
 }
-let B = class extends A {
+let NonSubModelLoader = class extends SubModelLoader {
   createSubModelBySlot() {
-    throw y("single document does not support async slot.");
+    throw subModelLoaderErrorFn("single document does not support async slot.");
   }
   createSubModelByComponent() {
-    throw y("single document does not support async component.");
+    throw subModelLoaderErrorFn("single document does not support async component.");
   }
   loadSubModelByComponent() {
-    throw y("single document does not support async component.");
+    throw subModelLoaderErrorFn("single document does not support async component.");
   }
   loadSubModelBySlot() {
-    throw y("single document does not support async slot.");
+    throw subModelLoaderErrorFn("single document does not support async slot.");
   }
   getLoadedModelBySlot() {
-    throw y("single document does not support async slot.");
+    throw subModelLoaderErrorFn("single document does not support async slot.");
   }
   getLoadedModelByComponent() {
-    throw y("single document does not support async component.");
+    throw subModelLoaderErrorFn("single document does not support async component.");
   }
 };
-B = ie([
-  w()
-], B);
-class p {
+NonSubModelLoader = __decorateClass([
+  Injectable()
+], NonSubModelLoader);
+class SyncConnector {
   /**
    * 当文档加载完成时触发的观察者
    */
@@ -773,187 +1180,237 @@ class p {
    * 当文档 awareness 状态变更时触发的观察者
    */
   onStateChange;
-  loadEvent = new l();
-  stateChangeEvent = new l();
+  loadEvent = new Subject();
+  stateChangeEvent = new Subject();
   constructor() {
-    this.onLoad = this.loadEvent.asObservable(), this.onStateChange = this.stateChangeEvent.asObservable();
+    this.onLoad = this.loadEvent.asObservable();
+    this.onStateChange = this.stateChangeEvent.asObservable();
   }
 }
-class ge extends p {
+class HocuspocusConnector extends SyncConnector {
   provide;
-  constructor(e) {
-    super(), this.provide = new J({
-      ...e,
-      onSynced: (s) => {
-        e.onSynced?.(s), this.loadEvent.next();
+  constructor(config) {
+    super();
+    this.provide = new HocuspocusProvider({
+      ...config,
+      onSynced: (data) => {
+        config.onSynced?.(data);
+        this.loadEvent.next();
       },
-      onAwarenessUpdate: (s) => {
-        e.onAwarenessUpdate?.(s);
-        const n = s.states.map((o) => ({
-          clientId: o.clientId,
-          message: o.message
-        }));
-        this.stateChangeEvent.next(n);
+      onAwarenessUpdate: (data) => {
+        config.onAwarenessUpdate?.(data);
+        const states = data.states.map((state) => {
+          return {
+            clientId: state.clientId,
+            message: state.message
+          };
+        });
+        this.stateChangeEvent.next(states);
       }
     });
   }
-  setLocalStateField(e, s) {
-    this.provide.setAwarenessField(e, s);
+  setLocalStateField(key, data) {
+    this.provide.setAwarenessField(key, data);
   }
   onDestroy() {
-    this.provide.disconnect(), this.provide.destroy();
+    this.provide.disconnect();
+    this.provide.destroy();
   }
 }
-class ye extends p {
+class YWebsocketConnector extends SyncConnector {
   provide;
-  onSync = (e) => {
-    e && this.loadEvent.next();
+  onSync = (is) => {
+    if (is) {
+      this.loadEvent.next();
+    }
   };
   onUpdate = () => {
-    const e = [];
-    this.provide.awareness.getStates().forEach((s, n) => {
-      e.push({
-        clientId: n,
-        message: s.message
+    const syncStates = [];
+    this.provide.awareness.getStates().forEach((state, id) => {
+      syncStates.push({
+        clientId: id,
+        message: state.message
       });
-    }), this.stateChangeEvent.next(e);
+    });
+    this.stateChangeEvent.next(syncStates);
   };
-  constructor(e, s, n) {
-    super(), this.onLoad = this.loadEvent.asObservable(), this.onStateChange = this.stateChangeEvent.asObservable(), this.provide = new Q(e, s, n), this.provide.once("sync", this.onSync), this.provide.awareness.on("update", this.onUpdate);
+  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(e, s) {
-    this.provide.awareness.setLocalStateField(e, s);
+  setLocalStateField(key, data) {
+    this.provide.awareness.setLocalStateField(key, data);
   }
   onDestroy() {
-    this.provide.awareness.off("update", this.onUpdate), this.provide.disconnect(), this.provide.destroy();
+    this.provide.awareness.off("update", this.onUpdate);
+    this.provide.disconnect();
+    this.provide.destroy();
   }
 }
-class me {
-  constructor(e) {
-    this.config = e;
+class CollaborateModule {
+  constructor(config) {
+    this.config = config;
   }
   config;
-  subscription = new _();
+  subscription = new Subscription();
   providers = [
-    f,
-    E,
+    Collaborate,
+    CollabHistory,
     {
-      provide: L,
-      useExisting: E
+      provide: History,
+      useExisting: CollabHistory
     },
     {
-      provide: p,
-      useFactory: (e) => this.config.createConnector(e.yDoc),
-      deps: [f]
+      provide: SyncConnector,
+      useFactory: (collab) => {
+        return this.config.createConnector(collab.yDoc);
+      },
+      deps: [Collaborate]
     },
     {
-      provide: A,
-      useClass: B
+      provide: SubModelLoader,
+      useClass: NonSubModelLoader
     }
   ];
   timer = null;
-  setup(e) {
-    const s = e.get(z, null), n = e.get(p), o = e.get(f);
-    if (s) {
-      const r = e.get(j);
-      n.setLocalStateField("message", s.get(e)), this.subscription.add(
-        s.onSync.subscribe(() => {
-          n.setLocalStateField("message", s.get(e));
+  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));
         }),
-        r.onChange.subscribe(() => {
-          n.setLocalStateField("message", s.get(e));
+        selection.onChange.subscribe(() => {
+          connector.setLocalStateField("message", messageBus.get(textbus));
         }),
-        n.onStateChange.subscribe((a) => {
-          s.consume(a, e);
+        connector.onStateChange.subscribe((states) => {
+          messageBus.consume(states, textbus);
         })
       );
     }
-    return n.onLoad.toPromise().then(() => {
-      if (!this.config.onlyLoad)
+    return connector.onLoad.toPromise().then(() => {
+      if (!this.config.onlyLoad) {
         return;
-      const r = o.yDoc.getMap("RootComponent");
-      if (!r.has("state"))
-        return new Promise((a) => {
-          const i = () => {
-            r.has("state") ? a() : this.timer = setTimeout(i, 1e3);
-          };
-          this.timer = setTimeout(i, 1e3);
-        });
+      }
+      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(e) {
-    this.subscription.unsubscribe(), e.get(f).destroy(), e.get(L).destroy(), e.get(p).onDestroy(), clearTimeout(this.timer);
+  onDestroy(textbus) {
+    this.subscription.unsubscribe();
+    textbus.get(Collaborate).destroy();
+    textbus.get(History).destroy();
+    textbus.get(SyncConnector).onDestroy();
+    clearTimeout(this.timer);
   }
 }
-class be {
-  constructor(e) {
-    this.config = e;
+class MultipleDocumentCollaborateModule {
+  constructor(config) {
+    this.config = config;
   }
   config;
-  subscription = new _();
+  subscription = new Subscription();
   providers = [
-    f,
-    k,
+    Collaborate,
+    MultipleDocCollabHistory,
     {
-      provide: L,
-      useExisting: k
+      provide: History,
+      useExisting: MultipleDocCollabHistory
     },
     {
-      provide: p,
-      useFactory: (e) => this.config.createConnector(e.yDoc),
-      deps: [f]
+      provide: SyncConnector,
+      useFactory: (collab) => {
+        return this.config.createConnector(collab.yDoc);
+      },
+      deps: [Collaborate]
     },
     {
-      provide: A,
-      useFactory: () => this.config.subModelLoader
+      provide: SubModelLoader,
+      useFactory: () => {
+        return this.config.subModelLoader;
+      }
     }
   ];
   timer = null;
-  setup(e) {
-    const s = e.get(z, null), n = e.get(p), o = e.get(f);
-    if (s) {
-      const r = e.get(j);
-      n.setLocalStateField("message", s.get(e)), this.subscription.add(
-        s.onSync.subscribe(() => {
-          n.setLocalStateField("message", s.get(e));
+  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));
         }),
-        r.onChange.subscribe(() => {
-          n.setLocalStateField("message", s.get(e));
+        selection.onChange.subscribe(() => {
+          connector.setLocalStateField("message", messageBus.get(textbus));
         }),
-        n.onStateChange.subscribe((a) => {
-          s.consume(a, e);
+        connector.onStateChange.subscribe((states) => {
+          messageBus.consume(states, textbus);
         })
       );
     }
-    return n.onLoad.toPromise().then(() => {
-      if (!this.config.onlyLoad)
+    return connector.onLoad.toPromise().then(() => {
+      if (!this.config.onlyLoad) {
         return;
-      const r = o.yDoc.getMap("RootComponent");
-      if (!r.has("state"))
-        return new Promise((a) => {
-          const i = () => {
-            r.has("state") ? a() : this.timer = setTimeout(i, 1e3);
-          };
-          this.timer = setTimeout(i, 1e3);
-        });
+      }
+      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(e) {
-    this.subscription.unsubscribe(), e.get(f).destroy(), e.get(L).destroy(), e.get(p).onDestroy(), clearTimeout(this.timer);
+  onDestroy(textbus) {
+    this.subscription.unsubscribe();
+    textbus.get(Collaborate).destroy();
+    textbus.get(History).destroy();
+    textbus.get(SyncConnector).onDestroy();
+    clearTimeout(this.timer);
   }
 }
 export {
-  E as CollabHistory,
-  f as Collaborate,
-  me as CollaborateModule,
-  pe as CustomUndoManagerConfig,
-  ge as HocuspocusConnector,
-  z as MessageBus,
-  k as MultipleDocCollabHistory,
-  be as MultipleDocumentCollaborateModule,
-  B as NonSubModelLoader,
-  A as SubModelLoader,
-  p as SyncConnector,
-  ye as YWebsocketConnector
+  CollabHistory,
+  Collaborate,
+  CollaborateModule,
+  CustomUndoManagerConfig,
+  HocuspocusConnector,
+  MessageBus,
+  MultipleDocCollabHistory,
+  MultipleDocumentCollaborateModule,
+  NonSubModelLoader,
+  SubModelLoader,
+  SyncConnector,
+  YWebsocketConnector
 };
 //# sourceMappingURL=index.esm.js.map