@univerjs-pro/collaboration-client 0.1.9

package/lib/es/index.js

@@ -0,0 +1,3626 @@
+var ws = Object.defineProperty;
+var Ms = (i, e, t) => e in i ? ws(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var l = (i, e, t) => (Ms(i, typeof e != "symbol" ? e + "" : e, t), t);
+import { Disposable as X, toDisposable as T, UniverInstanceType as M, IUniverInstanceService as k, DisposableCollection as Jt, IConfigService as z, ILogService as D, ISnapshotServerService as qt, RxDisposable as L, LocaleService as H, ILocalStorageService as Ds, Tools as P, ICommandService as O, TextX as Ns, UniverPermissionService as Ke, IUndoRedoService as J, sequenceExecute as As, OnLifecycle as ee, LifecycleStages as te, CommandType as Zt, Rectangle as Us, ThemeService as Qt, Workbook as ks, textEncoder as Mt, b64DecodeUnicode as Dt, LocalUndoRedoService as Ls, IContextService as $s, COLORS as De, ColorKit as Ps, Plugin as xs } from "@univerjs/core";
+import { MessageType as be } from "@univerjs/design";
+import { IBeforeCloseService as es, IMessageService as Me, INotificationService as Hs, useObservable as js, DesktopUIPart as Bs, IUIController as Vs } from "@univerjs/ui";
+import { CollaborationEvent as m, parseChangesetToProtocol as Fs, RevisionService as $, isTransformMutationFailure as Le, isTransformMutationsWithChangesetSuccess as _e, ITransformService as W, mapDocumentTypeToUniverType as ts, isTransformChangesetsSuccess as St, CompressMutationService as vt, parseProtocolChangeset as Nt, SnapshotService as Ws, isTransformMutationsWithChangesetFailure as At } from "@univerjs-pro/collaboration";
+import { createIdentifier as pt, Inject as _, Injector as I, Optional as Ye } from "@wendellhu/redi";
+import { merge as Ct, Subject as ae, BehaviorSubject as U, distinctUntilChanged as Gs, fromEvent as ss, of as Te, takeUntil as R, debounceTime as is, filter as Ut, switchMap as ot, combineLatest as ns, shareReplay as Ks, mapTo as Ys, concatMap as Xs } from "rxjs";
+import { map as ce, takeUntil as It, take as $e, filter as kt, delay as Lt, shareReplay as zs, switchMap as rs } from "rxjs/operators";
+import { IMEInputManagerService as Qe, TextSelectionManagerService as os, serializeTextRange as as, DocStateChangeManagerService as Js, SetTextSelectionsOperation as qs, RichTextEditingMutation as Zs, getDocObject as Qs, DocSkeletonManagerService as ei } from "@univerjs/docs";
+import { HTTPService as Re, WebSocketService as cs, IHTTPImplementation as ti, XHRHTTPImplementation as si, ThresholdInterceptorFactory as ii } from "@univerjs/network";
+import { SelectionManagerService as hs, SetSelectionsOperation as at, InsertSheetMutation as ni, RefRangeService as ri, EffectRefRangId as j, handleIRemoveRow as oi, handleIRemoveCol as ai, handleMoveRange as ci, handleInsertRow as hi, handleInsertRangeMoveRight as li, handleInsertRangeMoveDown as _i, handleInsertCol as ui, handleDeleteRangeMoveUp as di, handleDeleteRangeMoveLeft as gi, runRefRangeMutations as mi, SetWorksheetActivateCommand as fi } from "@univerjs/sheets";
+import { deserializeRangeWithSheet as Si, serializeRangeWithSheet as vi } from "@univerjs/engine-formula";
+import Et from "lodash/debounce";
+import { Shape as ls, Rect as ct, Vector2 as $t, IRenderManagerService as _s, NodePositionConvertToCursor as pi, getColor as Ne, TEXT_RANGE_LAYER_INDEX as Ae, RegularPolygon as Ci } from "@univerjs/engine-render";
+import { VIEWPORT_KEY as Ii, getCoordByCell as Pt, getSheetObject as Ei, SheetSkeletonManagerService as bi } from "@univerjs/sheets-ui";
+import { useDependency as Ti, connectInjector as Ri } from "@wendellhu/redi/react-bindings";
+import oe, { forwardRef as bt, useRef as yi, createElement as Tt } from "react";
+import Oi from "clsx";
+import { IRemoteInstanceService as wi } from "@univerjs/rpc";
+var x = /* @__PURE__ */ ((i) => (i[i.UNIVER_UNKNOWN = 0] = "UNIVER_UNKNOWN", i[i.UNIVER_DOC = 1] = "UNIVER_DOC", i[i.UNIVER_SHEET = 2] = "UNIVER_SHEET", i[i.UNIVER_SLIDE = 3] = "UNIVER_SLIDE", i[i.UNRECOGNIZED = -1] = "UNRECOGNIZED", i))(x || {}), C = /* @__PURE__ */ ((i) => (i[i.UNKNOWN_CMD = 0] = "UNKNOWN_CMD", i[i.HELLO = 1] = "HELLO", i[i.JOIN = 2] = "JOIN", i[i.LEAVE = 3] = "LEAVE", i[i.INGEST = 4] = "INGEST", i[i.HEARTBEAT = 5] = "HEARTBEAT", i[i.RECV = 6] = "RECV", i[i.UNRECOGNIZED = -1] = "UNRECOGNIZED", i))(C || {}), Rt = /* @__PURE__ */ ((i) => (i[i.UNKNOWN_CODE = 0] = "UNKNOWN_CODE", i[i.OK = 1] = "OK", i[i.FAIL = 2] = "FAIL", i[i.UNRECOGNIZED = -1] = "UNRECOGNIZED", i))(Rt || {}), Mi = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Di = (i, e) => (t, s) => e(t, s, i);
+let Z = class extends X {
+  constructor(e) {
+    super();
+    l(this, "_roomMembers", /* @__PURE__ */ new Map());
+    l(this, "_currentUser", null);
+    this._univerInstanceService = e, this.disposeWithMe(
+      T(
+        Ct(
+          this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_SHEET).pipe(ce((t) => t.getUnitId())),
+          this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_DOC).pipe(ce((t) => t.getUnitId())),
+          this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_SLIDE).pipe(ce((t) => t.getUnitId()))
+        ).subscribe((t) => this._removeRoom(t))
+      )
+    );
+  }
+  setCurrentUser(e) {
+    this._currentUser = e;
+  }
+  getCurrentUser() {
+    return this._currentUser;
+  }
+  updateMember(e, t) {
+    let s = this._roomMembers.get(e);
+    s || (s = new Ni(), this._roomMembers.set(e, s)), s.updateMember(t);
+  }
+  removeMember(e, t) {
+    const s = this._roomMembers.get(e);
+    s && s.removeMember(t);
+  }
+  getRoom(e) {
+    return this._roomMembers.get(e);
+  }
+  getMember(e, t) {
+    const s = this._roomMembers.get(e);
+    if (s)
+      return s.getMember(t);
+  }
+  _removeRoom(e) {
+    const t = this._roomMembers.get(e);
+    t && (t.dispose(), this._roomMembers.delete(e));
+  }
+  dispose() {
+    this._roomMembers.forEach((e) => e.dispose()), this._roomMembers.clear();
+  }
+};
+Z = Mi([
+  Di(0, k)
+], Z);
+class Ni extends X {
+  constructor() {
+    super(...arguments);
+    l(this, "_members", /* @__PURE__ */ new Map());
+  }
+  dispose() {
+    this._members.clear();
+  }
+  updateMember(t) {
+    this._members.set(t.memberID, t);
+  }
+  removeMember(t) {
+    this._members.delete(t);
+  }
+  getMember(t) {
+    return this._members.get(t);
+  }
+}
+function Ai(i) {
+  var s, n, r;
+  const e = i.data, t = JSON.parse(e);
+  switch (t.cmd) {
+    case C.HEARTBEAT:
+    case C.HELLO: {
+      const o = t.infoRsp;
+      return { ...t, data: o, cmd: t.cmd };
+    }
+    case C.JOIN: {
+      const o = t.joinRsp;
+      return { ...t, data: o, cmd: t.cmd };
+    }
+    case C.RECV: {
+      const o = t.collaMsg;
+      switch (o.eventID) {
+        case m.CHANGESET_ACK:
+          return {
+            ...t,
+            data: { ...o, data: (s = o.csAckEvent) == null ? void 0 : s.cs },
+            cmd: t.cmd
+          };
+        case m.NEW_CHANGESETS:
+          return {
+            ...t,
+            data: { ...o, data: (n = o.newCsEvent) == null ? void 0 : n.cs },
+            cmd: t.cmd
+          };
+        case m.CHANGESET_REJ:
+          return {
+            ...t,
+            data: { ...o, data: (r = o.csRejEvent) == null ? void 0 : r.cs },
+            cmd: t.cmd
+          };
+        case m.UPDATE_CURSOR:
+          return {
+            ...t,
+            data: { ...o, data: o.updateCursorEvent },
+            cmd: t.cmd
+          };
+        case m.USERS_ENTER:
+          return {
+            ...t,
+            data: { ...o, data: o.joinEvent },
+            cmd: t.cmd
+          };
+        case m.USERS_LEAVE:
+          return {
+            ...t,
+            data: { ...o, data: o.leaveEvent },
+            cmd: t.cmd
+          };
+        case m.LIVESHARE_NEW_HOST:
+          return {
+            ...t,
+            data: { ...o, data: o.liveShareNewHost },
+            cmd: t.cmd
+          };
+        case m.LIVESHARE_FETCH_OPERATIONS:
+        case m.LIVESHARE_OPERATION:
+          return {
+            ...t,
+            data: { ...o, data: o.liveShareOperation },
+            cmd: t.cmd
+          };
+        case m.LIVESHARE_TERMINATE:
+          return {
+            ...t,
+            data: { ...o, data: o.liveShareNewHost },
+            cmd: t.cmd
+          };
+        case m.MSG_FOR_ERROR:
+          return {
+            ...t,
+            data: o,
+            cmd: t.cmd
+          };
+        default:
+          return t;
+      }
+    }
+    default:
+      return t;
+  }
+}
+function Ui(i) {
+  switch (i.cmd) {
+    case C.HEARTBEAT:
+    case C.HELLO:
+      return JSON.stringify({
+        cmd: i.cmd,
+        routeKey: i.routeKey
+      });
+    case C.INGEST: {
+      let e;
+      switch (i.data.eventID) {
+        case m.UPDATE_CURSOR: {
+          e = {
+            eventID: m.UPDATE_CURSOR,
+            updateCursorEvent: i.data.data
+          };
+          break;
+        }
+        case m.USERS_LEAVE: {
+          e = {
+            eventID: m.USERS_LEAVE,
+            leaveEvent: i.data.data
+          };
+          break;
+        }
+        case m.USERS_ENTER: {
+          e = {
+            eventID: m.USERS_ENTER,
+            joinEvent: i.data.data
+          };
+          break;
+        }
+        case m.LIVESHARE_NEW_HOST: {
+          e = {
+            eventID: m.LIVESHARE_NEW_HOST,
+            liveShareNewHost: i.data.data
+          };
+          break;
+        }
+        case m.LIVESHARE_OPERATION: {
+          e = {
+            eventID: m.LIVESHARE_OPERATION,
+            liveShareOperation: i.data.data
+          };
+          break;
+        }
+        case m.LIVESHARE_TERMINATE: {
+          e = {
+            eventID: m.LIVESHARE_TERMINATE,
+            liveShareTerminate: i.data.data
+          };
+          break;
+        }
+        case m.LIVESHARE_REQUEST_HOST: {
+          e = {
+            eventID: m.LIVESHARE_REQUEST_HOST,
+            liveShareRequestHost: i.data.data
+          };
+          break;
+        }
+        case m.LIVESHARE_FETCH_OPERATIONS: {
+          e = {
+            eventID: m.LIVESHARE_FETCH_OPERATIONS
+          };
+          break;
+        }
+        default:
+          e = {
+            eventID: i.data.eventID
+          };
+      }
+      return JSON.stringify({
+        cmd: i.cmd,
+        routeKey: i.routeKey,
+        collaMsg: e
+      });
+    }
+    case C.JOIN:
+      return JSON.stringify({
+        cmd: i.cmd,
+        routeKey: i.routeKey,
+        joinReq: i.data
+      });
+    case C.LEAVE:
+      return JSON.stringify({
+        cmd: i.cmd,
+        routeKey: i.routeKey,
+        leaveReq: i.data
+      });
+    default:
+      throw new Error("[serializeCombRequest]: should not fall into default branch!");
+  }
+}
+var ki = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, me = (i, e) => (t, s) => e(t, s, i);
+const us = pt(
+  "univer-pro.collaboration-client-socket-service"
+), Li = "COLLAB_SUBMIT_CHANGESET_URL", $i = "/universer-api/comb";
+function Pi(i, e, t) {
+  return `${i}/${e}/unit/${t}/new_changes`;
+}
+let ht = class {
+  constructor(i, e, t, s, n) {
+    this._http = i, this._ws = e, this._configService = t, this._logService = s, this._snapshotServerService = n;
+  }
+  /**
+   * Create a socket that would connect to the remote collaboration server. It would throw an error when the socket cannot be created.
+   *
+   * @param URL The URL of the remote server.
+   */
+  createSocket(i) {
+    const e = this._ws.createSocket(i);
+    if (!e)
+      throw new Error("[CollaborationSocketService]: failed to create socket!");
+    const t = new Jt(), s = new ae();
+    t.add(T(e.close$.subscribe((c) => s.next(c)))), t.add(T(() => s.complete()));
+    const n = new ae();
+    t.add(T(e.error$.subscribe((c) => n.next(c)))), t.add(T(() => n.complete()));
+    const r = new ae();
+    t.add(
+      T(
+        e.message$.subscribe((c) => {
+          const h = Ai(c);
+          r.next(h);
+        })
+      )
+    ), t.add(T(() => r.complete()));
+    const o = () => {
+      n.next(new Event("connection error")), s.next(new CloseEvent("connection error")), a.close();
+    }, a = {
+      memberID: "",
+      close$: s.asObservable(),
+      error$: n.asObservable(),
+      open$: e.open$,
+      message$: r.asObservable(),
+      send: (c) => {
+        if (c.cmd === C.INGEST) {
+          if (c.data.eventID === m.SUBMIT_CHANGESET) {
+            this._submitChangeset(a, c.data).catch((h) => {
+              this._logService.error(h), o();
+            });
+            return;
+          }
+          if (c.data.eventID === m.FETCH_MISSING) {
+            const h = c.data;
+            this._fetchMissChangesets(h).then((u) => {
+              r.next({
+                cmd: C.RECV,
+                code: Rt.OK,
+                routeKey: h.data.unitID,
+                routeType: "",
+                data: {
+                  eventID: m.PSEUDO_FETCH_MISSING_RESULT,
+                  data: {
+                    changesets: u
+                  }
+                }
+              });
+            }).catch((u) => {
+              this._logService.error(u), o();
+            });
+            return;
+          }
+        }
+        e.send(Ui(c));
+      },
+      close: () => {
+        e.close(), t.dispose();
+      }
+    };
+    return a;
+  }
+  async _submitChangeset(i, e) {
+    var a;
+    const { unitType: t, unitID: s, changeset: n } = e.data, r = {
+      unitID: s,
+      memberID: i.memberID,
+      type: t,
+      changeset: Fs(n)
+    }, o = Pi(
+      (a = this._configService.getConfig(Li)) != null ? a : $i,
+      t,
+      s
+    );
+    try {
+      await this._http.post(o, { body: r });
+    } catch (c) {
+      throw this._logService.error("[CollaborationSession]", "submit changeset error!"), c;
+    }
+  }
+  async _fetchMissChangesets(i) {
+    const { unitID: e, from: t, to: s, unitType: n } = i.data;
+    return (await this._snapshotServerService.fetchMissingChangesets({ metadata: void 0 }, {
+      unitID: e,
+      type: n,
+      from: t,
+      to: s
+    })).changesets;
+  }
+};
+ht = ki([
+  me(0, _(Re)),
+  me(1, _(cs)),
+  me(2, z),
+  me(3, D),
+  me(4, qt)
+], ht);
+var ds = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, N = (i, e) => (t, s) => e(t, s, i), he = /* @__PURE__ */ ((i) => (i[i.IDLE = 0] = "IDLE", i[i.JOINING = 1] = "JOINING", i[i.OFFLINE = 2] = "OFFLINE", i[i.ONLINE = 3] = "ONLINE", i))(he || {});
+const xi = "COLLAB_WEB_SOCKET_URL", Hi = "ws://127.0.0.1:8000/universer-api/comb/connect", ji = "HEARTBEAT_INTERVAL", Bi = 3e4, gs = "HEARTBEAT_TIMEOUT", ms = 1e4, Vi = "RETRY_CONNECTING_INTERVAL", Fi = 2e4, Wi = "RETRY_CONNECTING_MAX_COUNT", Gi = 3;
+let lt = class extends L {
+  constructor(e, t, s, n, r, o, a, c) {
+    super();
+    l(this, "_sessionStatus$", new U(
+      0
+      /* IDLE */
+    ));
+    l(this, "sessionStatus$", this._sessionStatus$.asObservable());
+    l(this, "_event$", new ae());
+    l(this, "event$", this._event$.asObservable());
+    l(this, "_socket");
+    l(this, "_socketMessageSubscription");
+    l(this, "_collaborationTimeoutTimer");
+    this._unitID = e, this._logService = s, this._beforeCloseService = n, this._messageService = r, this._configService = o, this._localeService = a, this._memberService = c, t.pipe(It(this.dispose$)).subscribe((h) => {
+      var u;
+      typeof h > "u" || (this._socket = h, h ? (this._joinRoom(h), this._socketMessageSubscription = this._socket.message$.subscribe((d) => {
+        d.routeKey === this._unitID && this._onCombEvent(d);
+      })) : (this._sessionStatus$.next(
+        2
+        /* OFFLINE */
+      ), (u = this._socketMessageSubscription) == null || u.unsubscribe(), this._socketMessageSubscription = null));
+    }), this.disposeWithMe(
+      this._beforeCloseService.registerOnClose(() => {
+        var h;
+        (h = this._socket) == null || h.send({ cmd: C.LEAVE, data: { roomID: this._unitID } });
+      })
+    );
+  }
+  get sessionStatus() {
+    return this._sessionStatus$.getValue();
+  }
+  getMemberID() {
+    var e, t;
+    return (t = (e = this._socket) == null ? void 0 : e.memberID) != null ? t : null;
+  }
+  dispose() {
+    super.dispose(), this.dispose$.next(), this.dispose$.complete();
+  }
+  _onCombEvent(e) {
+    e.cmd === C.JOIN ? this._onJoinRoomEvent(e) : e.cmd === C.RECV && this._onRecvEvent(e);
+  }
+  _joinRoom(e) {
+    this._sessionStatus$.next(
+      1
+      /* JOINING */
+    ), e.send({
+      cmd: C.JOIN,
+      routeKey: this._unitID,
+      routeType: "",
+      data: {
+        rooms: [
+          {
+            roomID: this._unitID
+          }
+        ]
+      }
+    });
+  }
+  _onJoinRoomEvent(e) {
+    var s;
+    if (e.code === Rt.FAIL) {
+      this._messageService.show({
+        type: be.Warning,
+        content: this._localeService.t("session.room-full")
+      }), this._sessionStatus$.next(
+        2
+        /* OFFLINE */
+      );
+      return;
+    }
+    this._sessionStatus$.next(
+      3
+      /* ONLINE */
+    );
+    const t = (s = e.data.roomInfos[this._unitID]) == null ? void 0 : s.members;
+    t && t.forEach((n) => this._memberService.updateMember(this._unitID, n));
+  }
+  _onRecvEvent(e) {
+    try {
+      const t = e.data;
+      switch (t.eventID) {
+        case m.USERS_ENTER:
+          this._onUserJoin(t), this._event$.next(t);
+          break;
+        case m.USERS_LEAVE:
+          this._onUserLeave(t), this._event$.next(t);
+          break;
+        case m.CHANGESET_ACK:
+          this._clearCollaborationTimeoutTimer(), this._event$.next(t);
+          break;
+        case m.MSG_FOR_ERROR:
+          this._logService.error(`save fail reason is ${JSON.stringify(t)}`), this._event$.next(t);
+          break;
+        default:
+          this._event$.next(t);
+      }
+    } catch (t) {
+      this._logService.error(t, e);
+    }
+  }
+  _onUserJoin(e) {
+    this._memberService.updateMember(this._unitID, e.data);
+  }
+  _onUserLeave(e) {
+    this._memberService.removeMember(this._unitID, e.data.memberID);
+  }
+  /**
+   * Send event to the collaboration server.
+   */
+  async send(e, t) {
+    if (this.sessionStatus !== 3 || !this._socket)
+      throw new Error("[CollaborationSession]: should not send message when the session is offline!");
+    try {
+      e.eventID === m.NEW_CHANGESETS && this._scheduleCollaborationTimeoutTimer(), this._socket.send({
+        cmd: C.INGEST,
+        routeKey: t,
+        routeType: "",
+        data: e
+      });
+    } catch (s) {
+      this._logService.error(s);
+    }
+  }
+  _scheduleCollaborationTimeoutTimer() {
+    var e;
+    this._collaborationTimeoutTimer = window.setTimeout(() => {
+      this._collaborationTimeoutTimer = null, this._messageService.show({
+        type: be.Error,
+        content: this._localeService.t("session.collaboration-timeout")
+      });
+    }, (e = this._configService.getConfig(gs)) != null ? e : ms);
+  }
+  _clearCollaborationTimeoutTimer() {
+    this._collaborationTimeoutTimer && (clearTimeout(this._collaborationTimeoutTimer), this._collaborationTimeoutTimer = null);
+  }
+};
+lt = ds([
+  N(2, D),
+  N(3, es),
+  N(4, Me),
+  N(5, z),
+  N(6, _(H)),
+  N(7, _(Z))
+], lt);
+let ye = class extends X {
+  constructor(e, t, s, n, r, o) {
+    super();
+    /**
+     * Socket for collaboration sessions. Session are by unitID but the socket is share by collaboration sessions.
+     */
+    l(this, "_socket$", new U(void 0));
+    l(this, "_sessions", /* @__PURE__ */ new Map());
+    l(this, "_status$", new U(
+      0
+      /* IDLE */
+    ));
+    l(this, "status$", this._status$.asObservable());
+    l(this, "_socketReady", !1);
+    l(this, "_sendHeartbeatTimer");
+    l(this, "_timeoutTimer");
+    l(this, "_retryConnectingTimer");
+    l(this, "_retryCount", 0);
+    this._injector = e, this._localeService = t, this._messageService = s, this._logService = n, this._configService = r, this._socketService = o;
+  }
+  get _socket() {
+    return this._socket$.getValue();
+  }
+  dispose() {
+    super.dispose(), this._sessions.forEach((e) => e.dispose()), this._sessions.clear(), this._status$.complete();
+  }
+  /**
+   * Require a collaboration session.
+   * @param unitID
+   * @returns a collaboration session.
+   */
+  async requireSession(e) {
+    if (this._sessions.has(e))
+      return this._sessions.get(e);
+    this._tryEnsureSocket();
+    const t = this._injector.createInstance(lt, e, this._socket$.asObservable());
+    return this._sessions.set(e, t), t;
+  }
+  _createSocket() {
+    var s;
+    const e = (s = this._configService.getConfig(xi)) != null ? s : Hi;
+    return this._socketService.createSocket(e);
+  }
+  /**
+   * Try to establish connection to the collaboration server.
+   *
+   * Will send heartbeat channel to the server to keep the connection alive.
+   */
+  _tryEnsureSocket() {
+    try {
+      const e = this._createSocket();
+      if (e) {
+        const t = e.send;
+        e.send = (s) => (this._rescheduleHeartbeatEvent(), t.apply(e, [s])), e.message$.subscribe((s) => this._onMessage(e, s)), e.error$.pipe($e(1)).subscribe((s) => this._logService.error("[CollaborationSessionService]: socket error", s)), e.open$.pipe($e(1)).subscribe(() => {
+          this._onConnectionOpen(e);
+        }), e.close$.pipe($e(1)).subscribe((s) => {
+          this._logService.debug("[CollaborationSessionService]", "socket close", s), this._onConnectionFailed();
+        });
+      }
+    } catch (e) {
+      this._logService.error(e), this._onConnectionFailed();
+    }
+  }
+  _onConnectionOpen(e) {
+    this._logService.debug("[CollaborationSessionService]", "socket open."), e.send({ cmd: C.HELLO }), this._rescheduleHeartbeatEvent();
+  }
+  _onConnectionFailed() {
+    var e;
+    this._status$.next(
+      2
+      /* OFFLINE */
+    ), this._socket$.next(null), this._clearTimeoutTimer(), this._clearHeartbeatTimer(), this._socketReady = !1, this._retryCount < ((e = this._configService.getConfig(Wi)) != null ? e : Gi) ? (this._scheduleReconnection(this._retryCount), this._retryCount += 1) : this._messageService.show({
+      type: be.Error,
+      content: this._localeService.t("session.connection-failed")
+    });
+  }
+  _scheduleReconnection(e) {
+    var s;
+    const t = ((s = this._configService.getConfig(Vi)) != null ? s : Fi) * 2 ** e;
+    this._messageService.show({
+      type: be.Warning,
+      content: this._localeService.t("session.will-retry")
+    }), this._retryConnectingTimer = setTimeout(() => {
+      this._tryEnsureSocket(), clearTimeout(this._retryConnectingTimer), this._retryConnectingTimer = null;
+    }, t);
+  }
+  _rescheduleHeartbeatEvent() {
+    var e;
+    this._clearHeartbeatTimer(), this._sendHeartbeatTimer = setTimeout(
+      () => this._sendHeartbeat(),
+      (e = this._configService.getConfig(ji)) != null ? e : Bi
+    );
+  }
+  _sendHeartbeat() {
+    this._socket.send({ cmd: C.HEARTBEAT }), this._waitForHeartbeatResponse();
+  }
+  _waitForHeartbeatResponse() {
+    var e;
+    this._timeoutTimer = setTimeout(
+      () => this._onConnectionFailed(),
+      (e = this._configService.getConfig(gs)) != null ? e : ms
+    );
+  }
+  _onMessage(e, t) {
+    const { cmd: s } = t;
+    s === C.HELLO && !this._socketReady && (e.memberID = t.data.memberID, this._socket$.next(e), this._status$.next(
+      3
+      /* ONLINE */
+    ), this._socketReady = !0), s === C.HEARTBEAT && this._clearTimeoutTimer(), this._rescheduleHeartbeatEvent();
+  }
+  _clearHeartbeatTimer() {
+    this._sendHeartbeatTimer != null && (clearTimeout(this._sendHeartbeatTimer), this._sendHeartbeatTimer = null);
+  }
+  _clearTimeoutTimer() {
+    this._timeoutTimer != null && (clearTimeout(this._timeoutTimer), this._timeoutTimer = null);
+  }
+};
+ye = ds([
+  N(0, _(I)),
+  N(1, _(H)),
+  N(2, Me),
+  N(3, D),
+  N(4, z),
+  N(5, us)
+], ye);
+var Ki = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, fe = (i, e) => (t, s) => e(t, s, i);
+const Yi = "LOCAL_CACHE_INTERVAL", Xi = 1e3;
+let y = class extends X {
+  constructor(e, t, s, n, r) {
+    super();
+    l(this, "_cachedData", /* @__PURE__ */ new Map());
+    l(this, "_saveTaskMap", /* @__PURE__ */ new Map());
+    l(this, "_disabled", !1);
+    this._configService = e, this._localStorageService = t, this._beforeCloseService = s, this._localeService = n, this._revisionService = r, this._setupBeforeClosingHandler();
+  }
+  disableLocalCache() {
+    this._disabled = !0;
+  }
+  enableLocalCache() {
+    this._disabled = !1;
+  }
+  dispose() {
+    this._exhaustSavingTask().then(() => super.dispose());
+  }
+  async loadOfflineData(e) {
+    return this._disabled ? null : this._localStorageService.getItem(xt(e));
+  }
+  async saveOfflineData(e, t) {
+    return !!this._localStorageService.setItem(e, t);
+  }
+  updateOfflineData(e, t, s, n) {
+    const r = this._revisionService.getCurrentRevForDocument(e);
+    this._cachedData.set(e, {
+      unitID: e,
+      type: t,
+      awaitingChangeset: s,
+      mutations: n,
+      rev: r
+    }), this._saveTaskMap.has(e) || this._scheduleSaving(e);
+  }
+  _scheduleSaving(e) {
+    const t = this._getSaveTimeout();
+    t === 0 ? this._saveCache(e) : this._saveTaskMap.set(e, setTimeout(() => this._saveCache(e), t));
+  }
+  _getSaveTimeout() {
+    var e;
+    return (e = this._configService.getConfig(Yi)) != null ? e : Xi;
+  }
+  _saveCache(e) {
+    const t = this._saveTaskMap.get(e);
+    return t !== void 0 && window.clearTimeout(t), this._localStorageService.setItem(xt(e), this._cachedData.get(e)).then(() => this._saveTaskMap.delete(e));
+  }
+  async _exhaustSavingTask() {
+    const e = [];
+    this._saveTaskMap.forEach((t, s) => {
+      window.clearTimeout(t), e.push(
+        this._saveCache(s).then(() => {
+          this._saveTaskMap.delete(s);
+        })
+      );
+    }), await Promise.all(e);
+  }
+  _setupBeforeClosingHandler() {
+    this.disposeWithMe(
+      this._beforeCloseService.registerBeforeClose(() => {
+        if (this._saveTaskMap.size)
+          return this._localeService.t("collaboration-client.offline-data-not-saved");
+      })
+    );
+  }
+};
+y = Ki([
+  fe(0, z),
+  fe(1, Ds),
+  fe(2, es),
+  fe(3, _(H)),
+  fe(4, _($))
+], y);
+function xt(i) {
+  return `unit-cache-${i}`;
+}
+const Xe = pt(
+  "univer-pro.collaboration-client.single-active-unit-service"
+);
+var fs = /* @__PURE__ */ ((i) => (i[i.NO_OTHER_CLIENTS_EDITING = 0] = "NO_OTHER_CLIENTS_EDITING", i[i.OTHER_CLIENTS_EDITING = 1] = "OTHER_CLIENTS_EDITING", i))(fs || {});
+const Ht = 3e4, jt = "ACTIVE_UNIT_EVENT_CHANNEL";
+class zi extends X {
+  constructor() {
+    super();
+    l(this, "_id", P.generateRandomId());
+    l(this, "_selfUnitIDs", /* @__PURE__ */ new Set());
+    l(this, "_unitOnClients", /* @__PURE__ */ new Map());
+    // unitID -> memberIDs
+    l(this, "_heartbeatTimer", null);
+    l(this, "_clearOtherTimers", /* @__PURE__ */ new Map());
+    l(this, "_unitStatus", /* @__PURE__ */ new Map());
+    this._init();
+  }
+  dispose() {
+    super.dispose(), this._clearOtherTimers.forEach((t, s) => this._removeClearOtherTimer(s)), this._heartbeatTimer && window.clearInterval(this._heartbeatTimer);
+  }
+  getUnitStatus$(t) {
+    return this._ensureSubject(t).pipe(Gs());
+  }
+  editingUnit(t) {
+    this._selfUnitIDs.size === 0 && this._scheduleHeartbeat(), this._selfUnitIDs.add(t), this._send({
+      type: 0,
+      memberID: this._id,
+      unitID: t
+    });
+  }
+  disposeUnit(t) {
+    this._selfUnitIDs.delete(t), this._selfUnitIDs.size === 0 && this._heartbeatTimer && window.clearInterval(this._heartbeatTimer);
+  }
+  _init() {
+    this.disposeWithMe(
+      T(
+        ss(window, "storage").subscribe((t) => {
+          if (t.key !== jt || !t.newValue)
+            return;
+          const s = JSON.parse(t.newValue);
+          this._handleEvent(s);
+        })
+      )
+    ), window.addEventListener(
+      "unload",
+      () => this._send({
+        type: 1,
+        memberID: this._id,
+        unitIDs: Array.from(this._selfUnitIDs)
+      })
+    );
+  }
+  _handleEvent(t) {
+    switch (t.type) {
+      case 0:
+        this._handleJoinEvent(t);
+        break;
+      case 1:
+        this._handleLeaveEvent(t);
+        break;
+      case 2:
+        this._handleHeartbeatEvent(t);
+        break;
+    }
+  }
+  _handleJoinEvent(t) {
+    const { unitID: s, memberID: n } = t;
+    if (!this._unitOnClients.has(s) || !this._unitOnClients.get(s).has(n)) {
+      const r = this._unitOnClients.get(s) || /* @__PURE__ */ new Set();
+      r.add(n), this._unitOnClients.set(s, r), this._scheduleClearOtherTimer(n), this._send({
+        type: 0,
+        memberID: this._id,
+        unitID: s
+      });
+    } else
+      this._ensureSubject(s).next(
+        1
+        /* OTHER_CLIENTS_EDITING */
+      );
+  }
+  _scheduleClearOtherTimer(t) {
+    this._removeClearOtherTimer(t);
+    const s = window.setTimeout(() => {
+      this._unitOnClients.forEach((n) => {
+        n.delete(t);
+      });
+    }, Ht * 2);
+    this._clearOtherTimers.set(t, s);
+  }
+  _removeClearOtherTimer(t) {
+    if (this._clearOtherTimers.has(t)) {
+      const s = this._clearOtherTimers.get(t);
+      s && window.clearTimeout(s), this._clearOtherTimers.set(t, null);
+    }
+  }
+  _handleLeaveEvent(t) {
+    const { memberID: s, unitIDs: n } = t;
+    n.forEach((r) => {
+      var a;
+      const o = this._unitOnClients.get(r);
+      o && (o.delete(s), (a = this._ensureSubject(r)) == null || a.next(
+        o.size === 0 ? 0 : 1
+      ));
+    }), this._removeClearOtherTimer(s);
+  }
+  _handleHeartbeatEvent(t) {
+    this._scheduleClearOtherTimer(t.memberID);
+  }
+  _send(t) {
+    localStorage.setItem(jt, JSON.stringify(t));
+  }
+  _scheduleHeartbeat() {
+    this._heartbeatTimer = window.setInterval(() => {
+      this._send({
+        type: 2,
+        memberID: this._id
+      });
+    }, Ht);
+  }
+  _ensureSubject(t) {
+    return this._unitStatus.has(t) || this._unitStatus.set(t, new U(
+      0
+      /* NO_OTHER_CLIENTS_EDITING */
+    )), this._unitStatus.get(t);
+  }
+}
+var Ji = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Bt = (i, e) => (t, s) => e(t, s, i);
+let Be = class {
+  constructor(i, e) {
+    this._injector = i, this._transformService = e;
+  }
+  transformIMECache(i) {
+    this._transformUndoRedoStack(i), this._transformPreviousActiveRange(i);
+  }
+  // Since local IME inputting, the data model layer has changed,
+  // so when there is a remote changeset arrives,
+  // you need to transform the remote changeset and then apply it to the data model.
+  transformRemoteChangeset(i) {
+    const e = this._injector.get(Qe), { redoCache: t } = e.getUndoRedoMutationParamsCache();
+    if (t.length === 0)
+      return i;
+    let s = P.deepClone(i.mutations[0]);
+    for (let n = 0; n < t.length; n++) {
+      const r = {
+        id: "doc.mutation.rich-text-editing",
+        params: {
+          ...t[n]
+        }
+      }, o = this._transformService.transformMutation(s, r, !1);
+      if (Le(o))
+        throw o.error;
+      s = o.m1Prime;
+    }
+    return {
+      ...P.deepClone(i),
+      mutations: [s]
+    };
+  }
+  _transformUndoRedoStack(i) {
+    const e = this._injector.get(Qe), {
+      undoCache: t,
+      redoCache: s
+    } = e.getUndoRedoMutationParamsCache();
+    if (t.length === 0 || s.length === 0)
+      return;
+    const n = [], r = [];
+    let o = P.deepClone(i.mutations[0]), a = P.deepClone(i.mutations[0]);
+    for (let c = t.length - 1; c >= 0; c--) {
+      const h = {
+        id: "doc.mutation.rich-text-editing",
+        params: {
+          ...t[c]
+        }
+      }, u = {
+        id: "doc.mutation.rich-text-editing",
+        params: {
+          ...s[c]
+        }
+      }, d = this._transformService.transformMutation(o, h, !1), f = this._transformService.transformMutation(a, u, !1);
+      if (Le(d))
+        throw d.error;
+      if (Le(f))
+        throw f.error;
+      n.unshift(d.m2Prime.params), r.unshift(f.m2Prime.params), o = d.m1Prime, a = f.m1Prime;
+    }
+    e.setUndoRedoMutationParamsCache({ undoCache: n, redoCache: r });
+  }
+  _transformPreviousActiveRange(i) {
+    const e = this._injector.get(Qe), t = e.getActiveRange();
+    if (t == null)
+      return;
+    const s = [{
+      id: "doc.mutation.rich-text-editing",
+      params: {
+        unitId: i.unitID,
+        actions: [],
+        textRanges: [t]
+      }
+    }], n = this._transformService.transformMutationsWithChangeset(i, s);
+    if (!_e(n))
+      throw n.error;
+    const r = n.m2Prime[0].params.textRanges;
+    Array.isArray(r) && r.length && e.setActiveRange(r[0]);
+  }
+};
+Be = Ji([
+  Bt(0, _(I)),
+  Bt(1, W)
+], Be);
+var qi = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Vt = (i, e) => (t, s) => e(t, s, i);
+let Ve = class {
+  constructor(i, e) {
+    this._injector = i, this._transformService = e;
+  }
+  transformSelections(i) {
+    var a;
+    const e = this._injector.get(os), t = (a = e.getSelections()) != null ? a : [], s = t == null ? void 0 : t.map(as);
+    if (s.length === 0)
+      return;
+    const n = [{
+      id: "doc.mutation.rich-text-editing",
+      params: {
+        unitId: i.unitID,
+        actions: [],
+        textRanges: s
+      }
+    }], r = this._transformService.transformMutationsWithChangeset(i, n);
+    if (!_e(r))
+      throw r.error;
+    const o = r.m2Prime[0].params.textRanges;
+    Array.isArray(o) && o.length && e.replaceTextRanges(o, !1);
+  }
+};
+Ve = qi([
+  Vt(0, _(I)),
+  Vt(1, W)
+], Ve);
+function Ss(i) {
+  let e = "";
+  for (const t of i) {
+    const { startOffset: s, endOffset: n, isActive: r } = t;
+    e.length && (e += ","), e += `${s}:${n}:${r ? "1" : "0"}`;
+  }
+  return e;
+}
+function Zi(i) {
+  const e = i.split(","), t = [];
+  for (const s of e) {
+    const [n, r, o] = s.split(":");
+    t.push({
+      startOffset: Number(n),
+      endOffset: Number(r),
+      collapsed: n === r,
+      isActive: o === "1"
+      /* Active */
+    });
+  }
+  return t.some((s) => s.isActive) || (t[0].isActive = !0), t;
+}
+class yt extends L {
+  constructor() {
+    super(...arguments);
+    l(this, "_collabCursorState$", new U(null));
+    l(this, "collabCursorState$", this._collabCursorState$.asObservable());
+  }
+  syncEditingCollabCursor(t) {
+    const { unitID: s, memberID: n, textRanges: r } = t, o = Ss(r), a = {
+      unitID: s,
+      memberID: n,
+      selection: o
+    };
+    this._collabCursorState$.next(a);
+  }
+}
+var Qi = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Ft = (i, e) => (t, s) => e(t, s, i);
+let Fe = class {
+  constructor(i, e) {
+    this._injector = i, this._transformService = e;
+  }
+  transformSelections(i) {
+    var h, u, d, f;
+    const e = this._injector.get(hs), { pluginName: t, unitId: s, sheetId: n } = e.getCurrent() || {}, r = (h = e.getSelections()) != null ? h : [];
+    if (r.length === 0 || !t || !s || !n)
+      return;
+    const o = [{
+      id: at.id,
+      params: {
+        unitId: s,
+        subUnitId: n,
+        pluginName: t,
+        selections: P.deepClone(r)
+      }
+    }], a = this._transformService.transformMutationsWithChangeset(i, o);
+    if (!_e(a))
+      throw a.error;
+    const c = (f = (d = (u = a.m2Prime[0]) == null ? void 0 : u.params) == null ? void 0 : d.selections) != null ? f : r;
+    Array.isArray(c) && c.length && this._injector.get(O).executeCommand(at.id, {
+      unitId: s,
+      subUnitId: n,
+      pluginName: t,
+      selections: c
+    });
+  }
+};
+Fe = Qi([
+  Ft(0, _(I)),
+  Ft(1, W)
+], Fe);
+const en = /* @__PURE__ */ new Set([ni.id]);
+function tn(i, e, t, s, n) {
+  var h, u, d, f;
+  const r = [];
+  for (const v of i)
+    if (en.has(v.id)) {
+      if (r.length > 0)
+        break;
+      r.push(v);
+      break;
+    } else
+      r.push(v);
+  const o = (u = (h = n.getCurrentUser()) == null ? void 0 : h.userID) != null ? u : "unknown", a = (f = (d = n.getCurrentUser()) == null ? void 0 : d.memberID) != null ? f : "unknown";
+  return {
+    changeset: {
+      unitID: e,
+      type: ts(t.getUnitType(e)),
+      baseRev: s.getCurrentRevForDocument(e),
+      revision: 0,
+      userID: o,
+      memberID: a,
+      mutations: r
+    },
+    pendingMutations: i.slice(r.length)
+  };
+}
+function sn(i, e, t, s, n) {
+  var u, d, f, v;
+  const o = [i.reduce((p, E) => {
+    var ge;
+    const { id: b } = p, { id: G, type: ue } = E, qe = (ge = p.params) != null ? ge : { actions: [] }, de = E.params;
+    if (b && b !== G)
+      throw new Error(`Cannot assemble a changeset from multiple mutations of different types: ${b} - ${G}.`);
+    return {
+      ...p,
+      id: G,
+      type: ue,
+      params: {
+        unitId: de.unitId,
+        textRanges: de.textRanges,
+        actions: Ns.compose(qe.actions, de.actions)
+      }
+    };
+  }, {})], a = (d = (u = n.getCurrentUser()) == null ? void 0 : u.userID) != null ? d : "unknown", c = (v = (f = n.getCurrentUser()) == null ? void 0 : f.memberID) != null ? v : "unknown";
+  return {
+    changeset: {
+      unitID: e,
+      type: ts(t.getUnitType(e)),
+      baseRev: s.getCurrentRevForDocument(e),
+      revision: 0,
+      userID: a,
+      memberID: c,
+      mutations: o
+    },
+    pendingMutations: []
+  };
+}
+var se = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, g = (i, e) => (t, s) => e(t, s, i);
+const nn = "SEND_CHANGESET_TIMEOUT", rn = 2e3;
+var w = /* @__PURE__ */ ((i) => (i.NOT_COLLAB = "not_collab", i.SYNCED = "synced", i.PENDING = "pending", i.AWAITING = "awaiting", i.AWAITING_WITH_PENDING = "awaiting_with_pending", i.FETCH_MISS = "fetch_missing", i.CONFLICT = "conflict", i.OFFLINE = "offline", i))(w || {});
+class ie {
+  // The sequence of these mutations should be: [_syncedMutations]-[_awaitingMutations]-[_pendingMutations]
+  constructor(e, t, s, n, r, o, a, c, h) {
+    /** Mutations that has been sent to the server but not yet acknowledged by the server.  */
+    l(this, "_awaitingChangeset", null);
+    /** Mutations that has not been sent to the server. */
+    l(this, "_pendingMutations", []);
+    this.unitID = e, this.type = t, this._handler = r, this._commandService = o, this._undoRedoService = a, this._revisionService = c, this._localCacheService = h, this._awaitingChangeset = s, this._pendingMutations = n;
+  }
+  /**
+   * Check if there are some changesets missing. If true, the state should abort this changeset and request
+   * for missing changesets. Missing changesets will later be passed to `onRemoteChangeset` method.
+   *
+   * @param changeset The changeset sent from the remote collaboration server.
+   * @returns There is some changeset missing.
+   */
+  _checkMissing(e) {
+    const t = this._revisionService.getCurrentRevForDocument(this.unitID);
+    return e.revision > t + 1 ? (this._handler.onMissingChangesets({
+      from: t,
+      to: e.revision - 1
+    }), !0) : !1;
+  }
+  /** Transform undo redo mutations in the undo redo stack.  */
+  _transformUndoredo(e) {
+    this._undoRedoService.transformUndoRedo(this.unitID, e);
+  }
+  /** Transform selections by calling the selection manager service. */
+  _transformSelections(e) {
+    var t, s;
+    (s = (t = this._handler).onTransformSelections) == null || s.call(t, e);
+  }
+  _transformIMECache(e) {
+    var t, s;
+    return (s = (t = this._handler).onTransformIME) == null ? void 0 : s.call(t, e);
+  }
+  _transformRemoteChangesetByIMECache(e) {
+    var t, s, n;
+    return (n = (s = (t = this._handler).onTransformRemoteChangesetByIMECache) == null ? void 0 : s.call(t, e)) != null ? n : e;
+  }
+  // TODO: @jocs, doc and sheet need to be split.
+  _syncEditingCollabCursor(e) {
+    var t, s;
+    if (this.type === x.UNIVER_DOC) {
+      const { unitID: n, mutations: r, memberID: o } = e, a = r[0].params.textRanges;
+      Array.isArray(a) && a.length > 0 && ((s = (t = this._handler).onSyncEditingCollabCursor) == null || s.call(t, {
+        unitID: n,
+        memberID: o,
+        textRanges: a
+      }));
+    }
+  }
+  /** @internal */
+  _updateLocalCache() {
+    this._localCacheService.updateOfflineData(
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      this._pendingMutations
+    );
+  }
+  _getCurrentRevision() {
+    return this._revisionService.getCurrentRevForDocument(this.unitID);
+  }
+  _incrementRevisionNumber() {
+    this._revisionService.incrementRevForDocument(this.unitID);
+  }
+  _executeRemoteChangeset(e) {
+    var n;
+    const t = this._transformRemoteChangesetByIMECache(e), s = As(t.mutations, this._commandService, {
+      fromCollab: !0
+    });
+    if (!s.result)
+      throw s.error instanceof Error ? s.error : new Error((n = s.error) != null ? n : "[CollaborationState]: apply error!");
+    this._transformIMECache(t), this._transformUndoredo(e), this._transformSelections(t), this._syncEditingCollabCursor(t), this._incrementRevisionNumber();
+  }
+}
+let Oe = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h) {
+    super(
+      e,
+      t,
+      null,
+      [],
+      s,
+      c,
+      a,
+      n,
+      r
+    );
+    l(this, "status", "synced");
+    this._injector = o, this._logService = h;
+  }
+  appendMutation(e) {
+    const t = this._injector.createInstance(B, this.unitID, this.type, [e], this._handler);
+    return t._schedule(), t._updateLocalCache(), t;
+  }
+  onRemoteChangeset(e) {
+    if (this._checkMissing(e))
+      return this._injector.createInstance(
+        F,
+        this.unitID,
+        this.type,
+        null,
+        [],
+        null,
+        [e],
+        this._handler
+      );
+    try {
+      return this._executeRemoteChangeset(e), this;
+    } catch (s) {
+      return this._logService.error("[CollaborationController]: remote changeset applied error.", s), this;
+    }
+  }
+  onRemoteAck() {
+    throw new Error("[SyncedState]: received acknowledgement.");
+  }
+  onRemoteRej() {
+    throw new Error("[SyncedState]: received rejection.");
+  }
+  toggleOffline() {
+    return this._injector.createInstance(Y, this.unitID, this.type, null, [], this._handler);
+  }
+  toggleOnline() {
+    return this;
+  }
+  resend() {
+    throw new Error("[SyncedState]: invalid calling to `resend`.");
+  }
+};
+Oe = se([
+  g(3, _($)),
+  g(4, _(y)),
+  g(5, _(I)),
+  g(6, J),
+  g(7, O),
+  g(8, D)
+], Oe);
+let B = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h, u, d, f, v, p) {
+    super(
+      e,
+      t,
+      null,
+      s,
+      n,
+      u,
+      p,
+      o,
+      a
+    );
+    l(this, "status", "pending");
+    l(this, "_scheduleTimestamp", null);
+    l(this, "_sendingTimer", null);
+    this._injector = r, this._memberService = c, this._logService = h, this._configService = d, this._transformService = f, this._univerInstanceService = v;
+  }
+  appendMutation(e) {
+    return this._pendingMutations.push(e), this._updateLocalCache(), this;
+  }
+  onRemoteChangeset(e) {
+    if (this._checkMissing(e))
+      return this._clearScheduledTask(), this._injector.createInstance(
+        F,
+        this.unitID,
+        this.type,
+        null,
+        this._pendingMutations,
+        null,
+        [e],
+        this._handler
+      );
+    try {
+      const s = this._transformService.transformMutationsWithChangeset(e, this._pendingMutations);
+      if (_e(s)) {
+        const { c1Prime: n, m2Prime: r } = s;
+        this._executeRemoteChangeset(n);
+        const o = this._injector.createInstance(
+          B,
+          this.unitID,
+          this.type,
+          r,
+          this._handler
+        );
+        return this._clearScheduledTask(), o._schedule(
+          this._scheduleTimestamp ? Math.max(0, (/* @__PURE__ */ new Date()).getTime() - this._scheduleTimestamp) : this._getSendChangesetTimeout()
+        ), o;
+      }
+      throw s.error;
+    } catch (s) {
+      return this._logService.error(s), this._onConflict();
+    }
+  }
+  onRemoteAck() {
+    throw new Error("[PendingState]: received acknowledgement.");
+  }
+  onRemoteRej() {
+    throw new Error("[PendingState]: received rejection.");
+  }
+  toggleOffline() {
+    return this._clearScheduledTask(), this._injector.createInstance(
+      Y,
+      this.unitID,
+      this.type,
+      null,
+      this._pendingMutations,
+      this._handler
+    );
+  }
+  toggleOnline() {
+    return this;
+  }
+  /**
+   * Schedule a task to send changeset to the server.
+   *
+   * @internal
+   */
+  _schedule(e) {
+    e = e != null ? e : this._getSendChangesetTimeout(), this._scheduleTimestamp = (/* @__PURE__ */ new Date()).getTime(), this._sendingTimer = setTimeout(() => {
+      this._clearScheduledTask();
+      let t = null;
+      switch (this.type) {
+        case x.UNIVER_SHEET: {
+          t = tn(
+            this._pendingMutations,
+            this.unitID,
+            this._univerInstanceService,
+            this._revisionService,
+            this._memberService
+          );
+          break;
+        }
+        case x.UNIVER_DOC: {
+          t = sn(
+            this._pendingMutations,
+            this.unitID,
+            this._univerInstanceService,
+            this._revisionService,
+            this._memberService
+          );
+          break;
+        }
+        default:
+          throw new Error(`[PendingState]: unhandled univer type: ${this.type} in _schedule.`);
+      }
+      const { changeset: s, pendingMutations: n } = t;
+      this._handler.onSendChangeset(s);
+      const r = n.length ? this._injector.createInstance(
+        V,
+        this.unitID,
+        this.type,
+        s,
+        n,
+        this._handler
+      ) : this._injector.createInstance(K, this.unitID, this.type, s, this._handler);
+      r._updateLocalCache(), this._handler.onStateChange(this, r);
+    }, e);
+  }
+  _getSendChangesetTimeout() {
+    var e;
+    return (e = this._configService.getConfig(nn)) != null ? e : rn;
+  }
+  resend() {
+    throw new Error("[PendingState]: invalid calling to `resend`.");
+  }
+  _clearScheduledTask() {
+    this._sendingTimer != null && (clearTimeout(this._sendingTimer), this._sendingTimer = null);
+  }
+  _onConflict() {
+    return this._clearScheduledTask(), this._injector.createInstance(
+      Q,
+      this.unitID,
+      this.type,
+      null,
+      this._pendingMutations,
+      this._handler
+    );
+  }
+};
+B = se([
+  g(4, _(I)),
+  g(5, _($)),
+  g(6, _(y)),
+  g(7, _(Z)),
+  g(8, D),
+  g(9, O),
+  g(10, z),
+  g(11, W),
+  g(12, k),
+  g(13, J)
+], B);
+let K = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h, u, d) {
+    super(
+      e,
+      t,
+      s,
+      [],
+      n,
+      c,
+      d,
+      o,
+      a
+    );
+    l(this, "status", "awaiting");
+    this._injector = r, this._logService = h, this._transformService = u;
+  }
+  appendMutation(e) {
+    const t = this._injector.createInstance(
+      V,
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      [e],
+      this._handler
+    );
+    return t._updateLocalCache(), t;
+  }
+  onRemoteChangeset(e) {
+    if (this._checkMissing(e))
+      return this._injector.createInstance(
+        F,
+        this.unitID,
+        this.type,
+        this._awaitingChangeset,
+        [],
+        null,
+        [e],
+        this._handler
+      );
+    try {
+      const s = this._transformService.transformChangesets(
+        [e],
+        [this._awaitingChangeset],
+        !1
+      );
+      if (St(s)) {
+        const { c1Prime: n, c2Prime: r } = s;
+        this._executeRemoteChangeset(n[0]), r[0].baseRev = this._getCurrentRevision();
+        const o = this._injector.createInstance(
+          K,
+          this.unitID,
+          this.type,
+          r[0],
+          this._handler
+        );
+        return o._updateLocalCache(), o;
+      }
+      return this._onConflict();
+    } catch (s) {
+      return this._logService.error(s), this._onConflict();
+    }
+  }
+  onRemoteAck(e) {
+    const t = this._revisionService.getCurrentRevForDocument(this.unitID);
+    if (e.revision < t - 1)
+      return this;
+    if (this._checkMissing(e))
+      return this._injector.createInstance(
+        F,
+        this.unitID,
+        this.type,
+        null,
+        // the awaiting changeset should be transform against to apply those mutations
+        [],
+        this._awaitingChangeset,
+        [],
+        // no queued remote changesets
+        this._handler
+      );
+    this._incrementRevisionNumber();
+    const n = this._injector.createInstance(Oe, this.unitID, this.type, this._handler);
+    return n._updateLocalCache(), n;
+  }
+  onRemoteRej() {
+    return this._onConflict();
+  }
+  toggleOffline() {
+    return this._injector.createInstance(
+      Y,
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      [],
+      this._handler
+    );
+  }
+  toggleOnline() {
+    return this;
+  }
+  resend() {
+    this._handler.onSendChangeset(this._awaitingChangeset);
+  }
+  _onConflict() {
+    return this._injector.createInstance(
+      Q,
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      [],
+      this._handler
+    );
+  }
+};
+K = se([
+  g(4, _(I)),
+  g(5, _($)),
+  g(6, _(y)),
+  g(7, O),
+  g(8, D),
+  g(9, W),
+  g(10, J)
+], K);
+let V = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h, u, d, f) {
+    super(
+      e,
+      t,
+      s,
+      n,
+      r,
+      h,
+      f,
+      a,
+      c
+    );
+    l(this, "status", "awaiting_with_pending");
+    this._injector = o, this._logService = u, this._transformService = d;
+  }
+  appendMutation(e) {
+    return this._pendingMutations.push(e), this;
+  }
+  onRemoteChangeset(e) {
+    if (this._checkMissing(e))
+      return this._injector.createInstance(
+        F,
+        this.unitID,
+        this.type,
+        this._awaitingChangeset,
+        this._pendingMutations,
+        null,
+        [e],
+        this._handler
+      );
+    try {
+      const s = this._transformService.transformChangesets(
+        [e],
+        [this._awaitingChangeset],
+        !1
+      );
+      if (St(s)) {
+        const { c1Prime: n, c2Prime: r } = s, o = this._transformService.transformMutationsWithChangeset(
+          n[0],
+          this._pendingMutations
+        );
+        if (_e(o)) {
+          const { c1Prime: a, m2Prime: c } = o;
+          return this._executeRemoteChangeset(a), r[0].baseRev = this._getCurrentRevision(), this._injector.createInstance(
+            V,
+            this.unitID,
+            this.type,
+            r[0],
+            c,
+            this._handler
+          );
+        }
+        throw o.error;
+      }
+      throw s.error;
+    } catch (s) {
+      return this._logService.error(s), this._onConflict();
+    }
+  }
+  onRemoteAck(e) {
+    if (this._checkMissing(e))
+      return this._injector.createInstance(
+        F,
+        this.unitID,
+        this.type,
+        null,
+        this._pendingMutations,
+        this._awaitingChangeset,
+        [],
+        // no queued remote changesets
+        this._handler
+      );
+    this._incrementRevisionNumber();
+    const s = this._injector.createInstance(
+      B,
+      this.unitID,
+      this.type,
+      this._pendingMutations,
+      this._handler
+    );
+    return s._schedule(), s._updateLocalCache(), s;
+  }
+  // override onRemoteRejection(changeset: IRejectedChangeset): CollaborationState {
+  onRemoteRej() {
+    return this._onConflict();
+  }
+  toggleOffline() {
+    return this._injector.createInstance(
+      Y,
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      this._pendingMutations,
+      this._handler
+    );
+  }
+  toggleOnline() {
+    return this;
+  }
+  resend() {
+    this._handler.onSendChangeset(this._awaitingChangeset);
+  }
+  _onConflict() {
+    return this._injector.createInstance(
+      Q,
+      this.unitID,
+      this.type,
+      null,
+      this._pendingMutations,
+      this._handler
+    );
+  }
+};
+V = se([
+  g(5, _(I)),
+  g(6, _($)),
+  g(7, _(y)),
+  g(8, O),
+  g(9, D),
+  g(10, W),
+  g(11, J)
+], V);
+let Q = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h, u, d, f) {
+    super(
+      e,
+      t,
+      s,
+      n,
+      r,
+      a,
+      c,
+      u,
+      h
+    );
+    l(this, "status", "conflict");
+    this._univerPermissionService = o, this._localeService = d, this._notificationService = f, this._showConflictNotification(), this._clearLocalCache(), this._disableEditing();
+  }
+  appendMutation() {
+    return this;
+  }
+  onRemoteChangeset() {
+    return this;
+  }
+  onRemoteAck() {
+    return this;
+  }
+  onRemoteRej() {
+    return this;
+  }
+  toggleOffline() {
+    return this;
+  }
+  toggleOnline() {
+    return this;
+  }
+  resend() {
+    throw new Error("[ConflictState]: invalid calling to `resend`.");
+  }
+  _clearLocalCache() {
+    this._localCacheService.updateOfflineData(this.unitID, this.type, null, []);
+  }
+  _showConflictNotification() {
+    this._notificationService.show({
+      title: this._localeService.t("conflict.title"),
+      content: this._localeService.t("conflict.content"),
+      type: "error",
+      duration: 0
+      // Never close because user may lost his/her data if he/she doesn't notice this notification.
+    });
+  }
+  _disableEditing() {
+    this._univerPermissionService.setEditable(this.unitID, !1);
+  }
+};
+Q = se([
+  g(5, _(Ke)),
+  g(6, O),
+  g(7, J),
+  g(8, _(y)),
+  g(9, _($)),
+  g(10, _(H)),
+  g(11, Hs)
+], Q);
+let Y = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h, u) {
+    super(
+      e,
+      t,
+      s,
+      n,
+      r,
+      h,
+      u,
+      a,
+      c
+    );
+    l(this, "status", "offline");
+    this._injector = o;
+  }
+  appendMutation(e) {
+    return this._pendingMutations.push(e), this._updateLocalCache(), this;
+  }
+  onRemoteChangeset(e) {
+    throw new Error("[OfflineState]: received changeset.");
+  }
+  onRemoteAck() {
+    throw new Error("[OfflineState]: received acknowledgement.");
+  }
+  onRemoteRej() {
+    throw new Error("[OfflineState]: received rejection.");
+  }
+  toggleOffline() {
+    return this;
+  }
+  toggleOnline() {
+    const { _injector: e, _pendingMutations: t, _awaitingChangeset: s, unitID: n, _handler: r, type: o } = this, a = vs(e, n, o, s, t, r);
+    return a instanceof B ? a._schedule() : (a instanceof V || a instanceof K) && a.resend(), a;
+  }
+  resend() {
+    throw new Error("[OfflineState]: invalid calling to `resend`.");
+  }
+};
+Y = se([
+  g(5, _(I)),
+  g(6, _($)),
+  g(7, _(y)),
+  g(8, O),
+  g(9, J)
+], Y);
+let F = class extends ie {
+  constructor(e, t, s, n, r, o, a, c, h, u, d, f, v, p) {
+    super(
+      e,
+      t,
+      s,
+      n,
+      a,
+      f,
+      v,
+      h,
+      u
+    );
+    l(this, "status", "fetch_missing");
+    this._acknowledgedAwaitingChangeset = r, this._queuedRemoteChangesets = o, this._injector = c, this._logService = d, this._transformService = p;
+  }
+  // eslint-disable-next-line max-lines-per-function
+  onMissedChangesetFetched(e) {
+    try {
+      const t = [...e, ...this._queuedRemoteChangesets], s = [this._awaitingChangeset || this._acknowledgedAwaitingChangeset].filter(
+        (c) => !!c
+      );
+      let n, r;
+      if (s.length) {
+        const c = this._transformService.transformChangesets(
+          t,
+          s,
+          !1
+        );
+        if (!St(c))
+          throw c.error;
+        n = c.c1Prime, r = c.c2Prime;
+      } else
+        n = t, r = [];
+      let o = this._pendingMutations;
+      n.forEach((c) => {
+        let h;
+        if (o.length) {
+          const u = this._transformService.transformMutationsWithChangeset(
+            c,
+            o
+          );
+          if (!_e(u))
+            throw u.error;
+          h = u.c1Prime, o = u.m2Prime;
+        } else
+          h = c;
+        this._executeRemoteChangeset(h);
+      }), this._acknowledgedAwaitingChangeset && this._incrementRevisionNumber(), this._awaitingChangeset && r.length && (r[0].baseRev = this._getCurrentRevision());
+      let a;
+      if (this._awaitingChangeset && o.length !== 0)
+        a = this._injector.createInstance(
+          V,
+          this.unitID,
+          this.type,
+          r[0],
+          o,
+          this._handler
+        );
+      else if (this._awaitingChangeset && o.length === 0)
+        r[0].baseRev = this._getCurrentRevision(), a = this._injector.createInstance(
+          K,
+          this.unitID,
+          this.type,
+          r[0],
+          this._handler
+        );
+      else if (o.length !== 0) {
+        const c = this._injector.createInstance(
+          B,
+          this.unitID,
+          this.type,
+          o,
+          this._handler
+        );
+        c._schedule(), a = c;
+      } else
+        a = this._injector.createInstance(Oe, this.unitID, this.type, this._handler);
+      return a._updateLocalCache(), a;
+    } catch (t) {
+      return this._logService.error("[FetchMissState]", "failed to apply missed changesets!", t), this._injector.createInstance(
+        Q,
+        this.unitID,
+        this.type,
+        this._awaitingChangeset,
+        this._pendingMutations,
+        this._handler
+      );
+    }
+  }
+  resend() {
+    throw new Error("[FetchingMissState]: invalid calling to `resend`.");
+  }
+  appendMutation(e) {
+    return this._pendingMutations.push(e), this;
+  }
+  onRemoteChangeset(e) {
+    return this._queuedRemoteChangesets.push(e), this;
+  }
+  onRemoteAck(e) {
+    if (this._awaitingChangeset)
+      return this._acknowledgedAwaitingChangeset = this._awaitingChangeset, this._awaitingChangeset = null, this;
+    throw new Error("[FetchingMissState]: not expected to receive ack when `this._awaitingChangeset` is null!");
+  }
+  onRemoteRej() {
+    return this._onConflict();
+  }
+  toggleOffline() {
+    return this._injector.createInstance(
+      Y,
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      this._pendingMutations,
+      this._handler
+    );
+  }
+  toggleOnline() {
+    return this;
+  }
+  _onConflict() {
+    return this._injector.createInstance(
+      Q,
+      this.unitID,
+      this.type,
+      this._awaitingChangeset,
+      this._pendingMutations,
+      this._handler
+    );
+  }
+};
+F = se([
+  g(7, _(I)),
+  g(8, _($)),
+  g(9, _(y)),
+  g(10, D),
+  g(11, O),
+  g(12, J),
+  g(13, W)
+], F);
+function vs(i, e, t, s, n, r) {
+  return s && n.length ? i.createInstance(V, e, t, s, n, r) : s ? i.createInstance(K, e, t, s, r) : n.length ? i.createInstance(B, e, t, n, r) : i.createInstance(Oe, e, t, r);
+}
+var ze = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, S = (i, e) => (t, s) => e(t, s, i);
+let Ie = class extends L {
+  constructor(e, t, s) {
+    super();
+    l(this, "_entities", /* @__PURE__ */ new Map());
+    l(this, "_entityInit$", new ae());
+    this._injector = e, this._collabSessionService = t, this._univerInstanceService = s, this._init();
+  }
+  dispose() {
+    super.dispose(), this._entities.forEach((e) => e.dispose()), this._entities.clear();
+  }
+  getCollabEntity(e) {
+    var t;
+    return (t = this._entities.get(e)) != null ? t : null;
+  }
+  getCollabEntity$(e) {
+    const t = this.getCollabEntity(e);
+    return t ? Te(t) : this._entityInit$.pipe(kt((s) => s.unitID === e));
+  }
+  _init() {
+    this._univerInstanceService.getTypeOfUnitAdded$(M.UNIVER_SHEET).pipe(R(this.dispose$), Lt(16)).subscribe(async (t) => {
+      const s = t.getUnitId(), n = await this._startCollaboration(s, x.UNIVER_SHEET);
+      this._entities.set(s, n);
+    }), this._univerInstanceService.getTypeOfUnitAdded$(M.UNIVER_DOC).pipe(R(this.dispose$), Lt(16)).pipe(kt((t) => !t.getUnitId().startsWith("__"))).subscribe(async (t) => {
+      const s = t.getUnitId(), n = await this._startCollaboration(s, x.UNIVER_DOC);
+      this._entities.set(s, n);
+    }), Ct(
+      this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_SHEET),
+      this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_DOC)
+    ).pipe(R(this.dispose$)).subscribe((t) => {
+      const s = t.getUnitId(), n = this._entities.get(s);
+      n && (n.dispose(), this._entities.delete(s));
+    });
+  }
+  /**
+   * Start collaboration on a document.
+   *
+   * @param unitID ID of the document to start collaboration.
+   * @returns A disposable to stop collaboration.
+   */
+  async _startCollaboration(e, t) {
+    const s = await this._collabSessionService.requireSession(e), n = this._injector.createInstance(this._getCtorByUniverType(t), e, t, s);
+    return await n.init(), this._entityInit$.next(n), n;
+  }
+  _getCtorByUniverType(e) {
+    switch (e) {
+      case x.UNIVER_DOC:
+        return _t;
+      case x.UNIVER_SHEET:
+        return ut;
+      default:
+        throw new Error(`[CollaborationController]: invalid univer type: ${e}`);
+    }
+  }
+};
+Ie = ze([
+  ee(te.Starting, Ie),
+  S(0, _(I)),
+  S(1, _(ye)),
+  S(2, k)
+], Ie);
+let We = class extends L {
+  constructor(e, t, s, n, r, o, a, c, h, u, d, f, v) {
+    super();
+    l(this, "_state$", new U(null));
+    l(this, "state$", this._state$.asObservable());
+    l(this, "_state");
+    l(this, "_collaborationPaused", !1);
+    l(this, "status$", this.state$.pipe(
+      ce((e) => e ? e.status : w.OFFLINE),
+      zs(1)
+    ));
+    /**
+     * Could not transit the state twice at the same time. So we put a lock here in case of implementation fault.
+     */
+    l(this, "_transitionLocked", !1);
+    l(this, "_remoteChangesetQueue", []);
+    this.unitID = e, this._type = t, this._session = s, this._injector = n, this._localCacheService = r, this._univerPermissionService = o, this._compressMutationService = a, this._localeService = c, this._revisionService = h, this._logService = u, this._commandService = d, this._messageService = f, this._singleActiveUnitService = v;
+  }
+  get state() {
+    return this._state;
+  }
+  async init() {
+    if (this.state)
+      throw new Error(
+        '[CollaborationEntity]: initial state has been created before. You should not call "init" twice.'
+      );
+    await this._init();
+  }
+  /**
+   * Pause collaboration on the document. Remote changesets would be inserted to a queue and wait for resuming.
+   * @returns a disposable which will resume collaboration when called.
+   */
+  pauseCollaboration() {
+    return this._collaborationPaused = !0, T(() => {
+      this._collaborationPaused = !1, this._exhaustRemoteChangesetQueue();
+    });
+  }
+  _updateState(e) {
+    this._state = e, this._state$.next(e);
+  }
+  async _init() {
+    var e;
+    return this._updateState(await this._createInitialState()), this._singleActiveUnitService && ((e = this._singleActiveUnitService) == null || e.editingUnit(this.unitID), this.disposeWithMe(
+      T(
+        this._singleActiveUnitService.getUnitStatus$(this.unitID).subscribe((t) => {
+          this._logService.debug("[CollaborationEntity]", "editing status changed to", t), t === fs.OTHER_CLIENTS_EDITING ? (this._messageService.show({
+            content: this._localeService.t("collaboration.single-unit.warning"),
+            type: be.Warning
+          }), this._univerPermissionService.setEditable(this.unitID, !1)) : this._univerPermissionService.setEditable(this.unitID, !0);
+        })
+      )
+    )), this.disposeWithMe(
+      T(
+        this._session.sessionStatus$.subscribe((t) => {
+          t === he.ONLINE ? this._toggleOnline() : t === he.OFFLINE && this._toggleOffline();
+        })
+      )
+    ), this.disposeWithMe(
+      T(
+        this._session.event$.subscribe((t) => {
+          try {
+            const s = t.eventID;
+            s === m.NEW_CHANGESETS ? this._onRemoteChangeset(Nt(t.data)) : s === m.CHANGESET_ACK ? this._onRemoteACK(t.data) : s === m.CHANGESET_REJ ? this._onRemoteRejected() : s === m.PSEUDO_FETCH_MISSING_RESULT && this._onFetchMissResult(
+              t.data.changesets.map(
+                (n) => Nt(n)
+              )
+            );
+          } catch (s) {
+            throw console.error("Error on receiving event", s), s;
+          }
+        })
+      )
+    ), this._state;
+  }
+  _unlockTransition() {
+    this._transitionLocked = !1;
+  }
+  _lockTransition() {
+    if (this._transitionLocked)
+      throw new Error(
+        "[CollaborationEntity]: cannot lock transition twice! This is an implementation error, meaning you transit the collaboration state again in the process of a previous transition. This should never happen."
+      );
+    this._transitionLocked = !0;
+  }
+  _onLocalMutation(e) {
+    this._lockTransition(), this._updateState(this._state.appendMutation(e)), this._unlockTransition();
+  }
+  _onRemoteChangeset(e) {
+    if (!(e.revision <= this._revisionService.getCurrentRevForDocument(this.unitID))) {
+      if (this._collaborationPaused) {
+        this._remoteChangesetQueue.push(e);
+        return;
+      }
+      this._applyRemoteChangeset(e);
+    }
+  }
+  _exhaustRemoteChangesetQueue() {
+    this._remoteChangesetQueue.forEach((e) => this._applyRemoteChangeset(e)), this._remoteChangesetQueue = [];
+  }
+  _applyRemoteChangeset(e) {
+    const t = this._compressMutationService.interceptor.fetchThroughInterceptors(
+      this._compressMutationService.interceptor.getInterceptPoints().COMPRESS_MUTATION_APPLY
+    )(e.mutations, null) || e.mutations, s = { ...e, mutations: t };
+    this._lockTransition(), this._updateState(this._state.onRemoteChangeset(s)), this._unlockTransition();
+  }
+  _onRemoteACK(e) {
+    this._lockTransition(), this._updateState(this._state.onRemoteAck(e)), this._unlockTransition();
+  }
+  _onRemoteRejected() {
+    this._lockTransition(), this._updateState(this._state.onRemoteRej()), this._unlockTransition();
+  }
+  _onFetchMissResult(e) {
+    if (!(this._state instanceof F))
+      throw new TypeError("[CollaborationEntity]: cannot apply missing results on other states!");
+    const t = e.map((s) => {
+      const n = this._compressMutationService.interceptor.fetchThroughInterceptors(
+        this._compressMutationService.interceptor.getInterceptPoints().COMPRESS_MUTATION_APPLY
+      )(s.mutations, null) || s.mutations;
+      return { ...s, mutations: n };
+    });
+    this._lockTransition(), this._updateState(this._state.onMissedChangesetFetched(t)), this._unlockTransition();
+  }
+  _toggleOffline() {
+    this._lockTransition(), this._updateState(this._state.toggleOffline()), this._unlockTransition();
+  }
+  _toggleOnline() {
+    this._lockTransition(), this._updateState(this._state.toggleOnline()), this._unlockTransition();
+  }
+  async _createInitialState() {
+    return new Promise((e) => {
+      this._session.sessionStatus$.pipe($e(1)).subscribe(async (t) => {
+        e(await this._createInitialStateImpl(t === he.ONLINE));
+      });
+    });
+  }
+  _createHandler() {
+    const e = this.unitID;
+    return {
+      onStateChange: (s, n) => {
+        if (s !== this._state)
+          throw new Error(
+            `[ClientCollaborationController]: invalid state transition! State transferred from is not the current state.
+Before: ${s.status}
+After: ${n.status}
+Current: ${this._state.status}`
+          );
+        this._updateState(n);
+      },
+      onSendChangeset: (s) => {
+        const n = {
+          eventID: m.SUBMIT_CHANGESET,
+          data: {
+            unitID: s.unitID,
+            unitType: this._type,
+            changeset: s,
+            memberID: this._session.getMemberID()
+          }
+        };
+        this._session.send(n, this.unitID);
+      },
+      onMissingChangesets: ({ from: s, to: n }) => {
+        this._logService.debug("[CollaborationEntity]", `fetching missing changesets from ${s} to ${n}`);
+        const r = {
+          eventID: m.FETCH_MISSING,
+          data: {
+            unitID: e,
+            unitType: this._type,
+            from: s,
+            to: n
+          }
+        };
+        this._session.send(r, this.unitID);
+      }
+    };
+  }
+  async _createInitialStateImpl(e) {
+    var a, c;
+    const t = await this._localCacheService.loadOfflineData(this.unitID), s = (a = t == null ? void 0 : t.mutations) != null ? a : [], n = (c = t == null ? void 0 : t.awaitingChangeset) != null ? c : null, r = this.unitID;
+    try {
+      this._replayCachedMutations(n, s);
+    } catch (h) {
+      this._logService.error(h);
+    }
+    const o = this._createHandler();
+    if (e) {
+      const h = vs(
+        this._injector,
+        r,
+        this._type,
+        n,
+        s,
+        o
+      );
+      return h instanceof B ? h._schedule() : (h instanceof V || h instanceof K) && h.resend(), h;
+    }
+    return this._injector.createInstance(Y, r, this._type, n, s, o);
+  }
+  _replayCachedMutations(e, t) {
+    var n, r;
+    const s = this._compressMutationService.interceptor.fetchThroughInterceptors(
+      this._compressMutationService.interceptor.getInterceptPoints().COMPRESS_MUTATION_APPLY
+    );
+    (n = s((e == null ? void 0 : e.mutations) || [], null)) == null || n.forEach(
+      (o) => this._commandService.executeCommand(o.id, o.params)
+    ), (r = s(t || [], null)) == null || r.forEach(
+      (o) => this._commandService.executeCommand(o.id, o.params)
+    );
+  }
+};
+We = ze([
+  S(3, _(I)),
+  S(4, _(y)),
+  S(5, _(Ke)),
+  S(6, _(vt)),
+  S(7, _(H)),
+  S(8, _($)),
+  S(9, D),
+  S(10, O),
+  S(11, Me),
+  S(12, Ye(Xe))
+], We);
+let _t = class extends We {
+  constructor(i, e, t, s, n, r, o, a, c, h, u, d, f, v, p, E, b) {
+    super(
+      i,
+      e,
+      t,
+      s,
+      n,
+      r,
+      o,
+      a,
+      c,
+      v,
+      p,
+      E,
+      b
+    ), this.unitID = i, this.type = e, this.session = t, this._docStateChangeManagerService = h, this._docTransformIMECacheService = u, this._docTransformSelectionsService = d, this._docSyncEditingCollabCursorService = f;
+  }
+  _createHandler() {
+    const i = super._createHandler();
+    return i.onTransformIME = (e) => this._docTransformIMECacheService.transformIMECache(e), i.onTransformSelections = (e) => this._docTransformSelectionsService.transformSelections(e), i.onSyncEditingCollabCursor = (e) => this._docSyncEditingCollabCursorService.syncEditingCollabCursor(e), i.onTransformRemoteChangesetByIMECache = (e) => this._docTransformIMECacheService.transformRemoteChangeset(e), i;
+  }
+  async _init() {
+    const i = await super._init();
+    return this._docStateChangeManagerService.docStateChange$.pipe(R(this.dispose$)).subscribe((e) => {
+      if (e == null)
+        return;
+      const { unitId: t, redoState: s, commandId: n } = e;
+      if (t !== this.unitID)
+        return;
+      const r = {
+        id: n,
+        type: Zt.MUTATION,
+        params: {
+          unitId: t,
+          actions: s.actions,
+          textRanges: null
+        }
+      };
+      this._onLocalMutation(r);
+    }), i;
+  }
+};
+_t = ze([
+  S(3, _(I)),
+  S(4, _(y)),
+  S(5, _(Ke)),
+  S(6, _(vt)),
+  S(7, _(H)),
+  S(8, _($)),
+  S(9, _(Js)),
+  S(10, _(Be)),
+  S(11, _(Ve)),
+  S(12, _(yt)),
+  S(13, D),
+  S(14, O),
+  S(15, Me),
+  S(16, Ye(Xe))
+], _t);
+let ut = class extends We {
+  constructor(i, e, t, s, n, r, o, a, c, h, u, d, f, v) {
+    super(
+      i,
+      e,
+      t,
+      s,
+      n,
+      r,
+      o,
+      a,
+      c,
+      u,
+      d,
+      f,
+      v
+    ), this.unitID = i, this.type = e, this.session = t, this._sheetTransformSelectionsService = h;
+  }
+  _createHandler() {
+    const i = super._createHandler();
+    return i.onTransformSelections = (e) => this._sheetTransformSelectionsService.transformSelections(e), i;
+  }
+  async _init() {
+    const i = await super._init();
+    return this.disposeWithMe(
+      this._commandService.onCommandExecuted((e, t) => {
+        if (e.type !== Zt.MUTATION || t != null && t.fromCollab || t != null && t.onlyLocal)
+          return;
+        const s = e.params;
+        if ((s == null ? void 0 : s.unitId) !== this.unitID)
+          return;
+        const n = e, r = this._compressMutationService.interceptor.fetchThroughInterceptors(
+          this._compressMutationService.interceptor.getInterceptPoints().COMPRESS_MUTATION_SEND
+        )([n], null) || [n];
+        this._onLocalMutation(r[0]);
+      })
+    ), i;
+  }
+};
+ut = ze([
+  S(3, _(I)),
+  S(4, _(y)),
+  S(5, _(Ke)),
+  S(6, _(vt)),
+  S(7, _(H)),
+  S(8, _($)),
+  S(9, _(Fe)),
+  S(10, D),
+  S(11, O),
+  S(12, Me),
+  S(13, Ye(Xe))
+], ut);
+const Wt = ["purple300", "jiqing500", "verdancy600", "red300", "blue400", "gold400"];
+class Ot extends X {
+  constructor() {
+    super(...arguments);
+    l(this, "_assignedColors", /* @__PURE__ */ new Map());
+    l(this, "_colorIndex", 0);
+  }
+  assignAColorForMemberID(t) {
+    if (this._assignedColors.has(t))
+      return this._assignedColors.get(t);
+    const s = Wt[this._colorIndex];
+    return this._colorIndex = (this._colorIndex + 1) % Wt.length, this._assignedColors.set(t, s), s;
+  }
+}
+var on = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, ne = (i, e) => (t, s) => e(t, s, i);
+const an = 300, cn = 100, hn = () => {
+  let i = [], e = !1;
+  return (t) => {
+    i.push(t), e || (e = !0, setTimeout(() => {
+      i.forEach((s) => s()), i = [], e = !1;
+    }));
+  };
+};
+let dt = class extends L {
+  constructor(e, t, s, n, r, o, a, c) {
+    super();
+    l(this, "_online", !1);
+    l(this, "_init", !1);
+    /** Cursor info of the collaboration room members. The key would be the memberID. */
+    l(this, "_cursorInfo$", new U(/* @__PURE__ */ new Map()));
+    l(this, "cursorInfo$", this._cursorInfo$.asObservable());
+    l(this, "_roomMembers$", new U([]));
+    l(this, "roomMembers$", this._roomMembers$.pipe(is(an)));
+    l(this, "_updateLocalCursor", Et((e, t) => {
+      const s = {
+        eventID: m.UPDATE_CURSOR,
+        data: {
+          unitID: this.unitID,
+          memberID: this._session.getMemberID(),
+          selection: vi(e, t.range)
+        }
+      };
+      this._session.send(s, this.unitID);
+    }, cn));
+    this.unitID = e, this._session = t, this._injector = s, this._colorAssignService = n, this._memberService = r, this._univerInstanceService = o, this._commandService = a, this._refRangeService = c;
+  }
+  get cursorInfo() {
+    return this._cursorInfo$.getValue();
+  }
+  get roomMembers() {
+    return this._roomMembers$.getValue();
+  }
+  dispose() {
+    super.dispose(), this._cursorInfo$.next(/* @__PURE__ */ new Map()), this._cursorInfo$.complete(), this._roomMembers$.next([]), this._roomMembers$.complete();
+  }
+  init() {
+    this._init || (this._init = !0, this._session.sessionStatus$.pipe(R(this.dispose$)).subscribe((e) => {
+      e === he.ONLINE ? this._toggleOnline() : this._toggleOffline();
+    }), this._session.event$.pipe(R(this.dispose$)).subscribe((e) => {
+      const t = e.eventID;
+      t === m.UPDATE_CURSOR && this._onCursorUpdate(e), t === m.USERS_LEAVE && this._onCursorDelete(e);
+    }), this._onRefRangeChange(), this.disposeWithMe(
+      this._commandService.onCommandExecuted((e) => {
+        if (this._online && e.id === at.id && e.params.unitId === this.unitID) {
+          const t = e.params;
+          this._updateLocalCursor(t.subUnitId, t.selections[0]);
+        }
+      })
+    ));
+  }
+  _onCursorUpdate(e) {
+    var h, u;
+    const { memberID: t, selection: s } = e.data, { sheetName: n, range: r } = Si(s), a = {
+      name: (u = (h = this._memberService.getMember(this.unitID, t)) == null ? void 0 : h.name) != null ? u : "Unknown user",
+      range: this._getMergeRange(n, r),
+      sheetID: n,
+      color: this._colorAssignService.assignAColorForMemberID(t),
+      selection: s
+    }, c = this.cursorInfo;
+    c.set(t, a), this._cursorInfo$.next(c);
+  }
+  _onCursorDelete(e) {
+    const { memberID: t } = e.data, s = this.cursorInfo;
+    s.delete(t), this._cursorInfo$.next(s);
+  }
+  _getMergeRange(e, t) {
+    var n, r;
+    const s = (r = (n = this._univerInstanceService.getUniverSheetInstance(this.unitID)) == null ? void 0 : n.getSheetBySheetId(e)) == null ? void 0 : r.getMergeData();
+    return (s == null ? void 0 : s.find((o) => Us.contains(o, t))) || t;
+  }
+  _onRefRangeChange() {
+    const e = new Jt(), t = hn(), s = () => {
+      e.dispose();
+      const n = (r, o, a, c) => {
+        let h = [];
+        switch (r.id) {
+          case j.DeleteRangeMoveLeftCommandId: {
+            h = gi(r, c);
+            break;
+          }
+          case j.DeleteRangeMoveUpCommandId: {
+            h = di(r, c);
+            break;
+          }
+          case j.InsertColCommandId: {
+            h = ui(r, c);
+            break;
+          }
+          case j.InsertRangeMoveDownCommandId: {
+            h = _i(r, c);
+            break;
+          }
+          case j.InsertRangeMoveRightCommandId: {
+            h = li(r, c);
+            break;
+          }
+          case j.InsertRowCommandId: {
+            h = hi(r, c);
+            break;
+          }
+          case j.MoveRangeCommandId: {
+            h = ci(r, c);
+            break;
+          }
+          case j.RemoveColCommandId: {
+            h = ai(r, c);
+            break;
+          }
+          case j.RemoveRowCommandId: {
+            h = oi(r, c);
+            break;
+          }
+        }
+        const u = mi(h, c), d = this.cursorInfo.get(o);
+        if (d && u) {
+          const f = {
+            ...d,
+            range: u
+          };
+          this.cursorInfo.set(o, f), t(() => {
+            const v = this._refRangeService.registerRefRange(u, (p) => (v.dispose(), n(p, o, a, u)));
+            e.add(v);
+          });
+        }
+        return {
+          redos: [],
+          undos: []
+        };
+      };
+      this.cursorInfo.forEach((r, o) => {
+        const { range: a, sheetID: c } = r, h = this._refRangeService.registerRefRange(a, (u) => (h.dispose(), n(u, o, c, a)));
+        e.add(h);
+      });
+    };
+    this.disposeWithMe(
+      T(
+        this._cursorInfo$.subscribe(() => {
+          s();
+        })
+      )
+    );
+  }
+  _toggleOnline() {
+    var s, n;
+    if (this._online = !0, ((s = this._univerInstanceService.getFocusedUnit()) == null ? void 0 : s.getUnitId()) !== this.unitID)
+      return;
+    const t = (n = this._injector.get(hs).getSelections()) == null ? void 0 : n[0];
+    t && this._updateLocalCursor(
+      this._univerInstanceService.getCurrentUnitForType(M.UNIVER_SHEET).getActiveSheet().getSheetId(),
+      t
+    );
+  }
+  _toggleOffline() {
+    this._online = !1;
+  }
+};
+dt = on([
+  ne(2, _(I)),
+  ne(3, _(Ot)),
+  ne(4, _(Z)),
+  ne(5, k),
+  ne(6, O),
+  ne(7, _(ri))
+], dt);
+var ln = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, q = (i, e) => (t, s) => e(t, s, i);
+const _n = 300, un = 100;
+let gt = class extends L {
+  constructor(e, t, s, n, r, o, a, c, h) {
+    super();
+    l(this, "_online", !1);
+    l(this, "_init", !1);
+    /** Cursor info of the collaboration room members. The key would be the memberID. */
+    l(this, "_cursorInfo$", new U(/* @__PURE__ */ new Map()));
+    l(this, "cursorInfo$", this._cursorInfo$.asObservable());
+    l(this, "_roomMembers$", new U([]));
+    l(this, "roomMembers$", this._roomMembers$.pipe(is(_n)));
+    l(this, "_updateLocalCursor", Et((e) => {
+      const t = {
+        eventID: m.UPDATE_CURSOR,
+        data: {
+          unitID: this.unitID,
+          memberID: this._session.getMemberID(),
+          selection: Ss(e)
+        }
+      };
+      this._session.send(t, this.unitID);
+    }, un));
+    this.unitID = e, this._session = t, this._injector = s, this._colorAssignService = n, this._memberService = r, this._syncEditingCollabCursorService = o, this._transformService = a, this._univerInstanceService = c, this._commandService = h;
+  }
+  get cursorInfo() {
+    return this._cursorInfo$.getValue();
+  }
+  get roomMembers() {
+    return this._roomMembers$.getValue();
+  }
+  dispose() {
+    super.dispose(), this._cursorInfo$.next(/* @__PURE__ */ new Map()), this._cursorInfo$.complete(), this._roomMembers$.next([]), this._roomMembers$.complete();
+  }
+  init() {
+    this._init || (this._init = !0, this._session.sessionStatus$.pipe(R(this.dispose$)).subscribe((e) => {
+      e === he.ONLINE ? this._toggleOnline() : this._toggleOffline();
+    }), this._session.event$.pipe(R(this.dispose$)).subscribe((e) => {
+      const t = e.eventID;
+      t === m.UPDATE_CURSOR && this._onCursorUpdate(e), t === m.USERS_LEAVE && this._onCursorDelete(e);
+    }), this.disposeWithMe(
+      this._commandService.onCommandExecuted((e) => {
+        const t = e.params;
+        t != null && this._online && e.id === qs.id && t.unitId === this.unitID && t.isEditing === !1 && this._updateLocalCursor(t.ranges);
+      })
+    ), this._syncEditingCollabCursorService.collabCursorState$.pipe(R(this.dispose$)).subscribe((e) => {
+      if ((e == null ? void 0 : e.unitID) !== this.unitID)
+        return;
+      const t = {
+        eventID: m.UPDATE_CURSOR,
+        data: e
+      };
+      this._onCursorUpdate(t);
+    }), this.disposeWithMe(
+      this._commandService.onCommandExecuted((e) => {
+        if (e.params == null)
+          return;
+        const t = e.params;
+        if (e.id !== Zs.id || t.unitId !== this.unitID)
+          return;
+        const s = {
+          id: "doc.mutation.rich-text-editing",
+          params: t
+        }, n = this.cursorInfo;
+        for (const [r, o] of n) {
+          const a = {
+            id: "doc.mutation.rich-text-editing",
+            params: {
+              unitId: this.unitID,
+              actions: [],
+              textRanges: o.ranges
+            }
+          }, c = this._transformService.transformMutation(s, a, !1);
+          if (Le(c))
+            throw c.error;
+          n.set(r, {
+            ...o,
+            ranges: c.m2Prime.params.textRanges
+          });
+        }
+        queueMicrotask(() => {
+          this._cursorInfo$.next(n);
+        });
+      })
+    ));
+  }
+  _onCursorUpdate(e) {
+    var c, h;
+    const { memberID: t, selection: s } = e.data, n = Zi(s), r = (h = (c = this._memberService.getMember(this.unitID, t)) == null ? void 0 : c.name) != null ? h : "Unknown user", o = {
+      color: this._colorAssignService.assignAColorForMemberID(t),
+      name: r,
+      ranges: n
+    }, a = this.cursorInfo;
+    a.set(t, o), this._cursorInfo$.next(a);
+  }
+  _onCursorDelete(e) {
+    const { memberID: t } = e.data, s = this.cursorInfo;
+    s.delete(t), this._cursorInfo$.next(s);
+  }
+  _toggleOnline() {
+    var n;
+    if (this._online = !0, ((n = this._univerInstanceService.getFocusedUnit()) == null ? void 0 : n.getUnitId()) !== this.unitID)
+      return;
+    const t = this._injector.get(os).getSelections(), s = t == null ? void 0 : t.map(as);
+    Array.isArray(s) && s.length > 0 && this._updateLocalCursor(s);
+  }
+  _toggleOffline() {
+    this._online = !1;
+  }
+};
+gt = ln([
+  q(2, _(I)),
+  q(3, _(Ot)),
+  q(4, _(Z)),
+  q(5, _(yt)),
+  q(6, W),
+  q(7, k),
+  q(8, O)
+], gt);
+var dn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, et = (i, e) => (t, s) => e(t, s, i);
+let le = class extends L {
+  constructor(e, t, s) {
+    super();
+    // The the kay would be the memberID.
+    l(this, "_entities", /* @__PURE__ */ new Map());
+    l(this, "_entityInit$", new ae());
+    this._univerInstanceService = e, this._injector = t, this._collabSessionService = s, this._init();
+  }
+  dispose() {
+    super.dispose(), this._entityInit$.complete(), this._entities.forEach((e) => e.dispose());
+  }
+  getCollabCursors$(e) {
+    return this._entities.has(e) ? this._entities.get(e).cursorInfo$ : this._entityInit$.pipe(
+      Ut((t) => t.unitID === e),
+      ot((t) => t.cursorInfo$)
+    );
+  }
+  _init() {
+    this._univerInstanceService.getTypeOfUnitAdded$(M.UNIVER_SHEET).pipe(R(this.dispose$)).subscribe(async (e) => {
+      const t = e.getUnitId(), s = await this._startSheetCollabCursor(t);
+      this._entityInit$.next(s), this._entities.set(t, s);
+    }), this._univerInstanceService.getTypeOfUnitAdded$(M.UNIVER_DOC).pipe(R(this.dispose$)).pipe(Ut((e) => !e.getUnitId().startsWith("__"))).subscribe(async (e) => {
+      const t = e.getUnitId(), s = await this._startDocCollabCursor(t);
+      this._entityInit$.next(s), this._entities.set(t, s);
+    }), Ct(
+      this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_DOC),
+      this._univerInstanceService.getTypeOfUnitDisposed$(M.UNIVER_SHEET)
+    ).pipe(R(this.dispose$)).subscribe((e) => {
+      const t = e.getUnitId(), s = this._entities.get(t);
+      s && (s.dispose(), this._entities.delete(t));
+    });
+  }
+  async _startSheetCollabCursor(e) {
+    const t = await this._collabSessionService.requireSession(e), s = this._injector.createInstance(dt, e, t);
+    return s.init(), s;
+  }
+  async _startDocCollabCursor(e) {
+    const t = await this._collabSessionService.requireSession(e), s = this._injector.createInstance(gt, e, t);
+    return s.init(), s;
+  }
+};
+le = dn([
+  ee(te.Starting, le),
+  et(0, k),
+  et(1, _(I)),
+  et(2, _(ye))
+], le);
+const we = 20, Gt = 200, tt = 4, gn = 5;
+function mn(i, e) {
+  let { radius: t, width: s, height: n } = e;
+  t = t != null ? t : 0, s = s != null ? s : 30, n = n != null ? n : 30;
+  let r = 0, o = 0, a = 0;
+  r = o = a = Math.min(t, s / 2, n / 2), i.beginPath(), i.moveTo(r, 0), i.lineTo(s - o, 0), i.arc(s - o, o, o, Math.PI * 3 / 2, 0, !1), i.lineTo(s, n - a), i.arc(s - a, n - a, a, 0, Math.PI / 2, !1), i.lineTo(0, n), i.lineTo(0, r), i.arc(r, r, r, Math.PI, Math.PI * 3 / 2, !1), i.closePath(), e.fill && (i.save(), i.fillStyle = e.fill, e.fillRule === "evenodd" ? i.fill("evenodd") : i.fill(), i.restore());
+}
+class Je extends ls {
+  constructor(t, s) {
+    super(t, s);
+    l(this, "color");
+    l(this, "text");
+    this.color = s == null ? void 0 : s.color, this.text = s == null ? void 0 : s.text;
+  }
+  static drawWith(t, s) {
+    const { text: n, color: r } = s;
+    t.save(), t.font = "bold 13px Source Han Sans CN";
+    const o = t.measureText(n).width, a = Math.min(
+      o + 2 * tt,
+      Gt
+    );
+    mn(t, {
+      height: we,
+      radius: 4,
+      width: a,
+      fill: r,
+      evented: !1
+    }), t.fillStyle = "#FFF";
+    const c = tt, h = we - gn, u = Gt - 2 * tt;
+    if (o > u) {
+      let d = "", f = 0;
+      for (const v of n) {
+        const p = t.measureText(v).width;
+        if (f + p <= u - t.measureText("...").width)
+          d += v, f += p;
+        else {
+          d += "...";
+          break;
+        }
+      }
+      t.fillText(d, c, h);
+    } else
+      t.fillText(n, c, h);
+    t.restore();
+  }
+  _draw(t) {
+    Je.drawWith(t, this);
+  }
+}
+const fn = 1, Sn = 1.5;
+class vn extends ls {
+  constructor(t, s) {
+    super(t, s);
+    l(this, "_color");
+    l(this, "_hovered", !1);
+    l(this, "_range");
+    l(this, "_name", "");
+    l(this, "_labelPosition", "top");
+    s && this.setShapeProps(s), this.onPointerEnterObserver.add(() => this.setShapeProps({ hovered: !0 })), this.onPointerLeaveObserver.add(() => this.setShapeProps({ hovered: !1 }));
+  }
+  setShapeProps(t) {
+    var s, n, r, o, a;
+    this._color = (s = t.color) != null ? s : this._color, this._hovered = (n = t.hovered) != null ? n : this._hovered, this._range = (r = t.range) != null ? r : this._range, this._name = (o = t.name) != null ? o : this._name, this._labelPosition = (a = t.labelPosition) != null ? a : this._labelPosition, this.transformByState({
+      width: t.width,
+      height: t.height
+    });
+  }
+  onMouseMove(t) {
+    const { row: s, column: n } = t;
+    if (s >= this._range.startRow && s <= this._range.endRow && n >= this._range.startColumn && n <= this._range.endColumn) {
+      this.setShapeProps({ hovered: !0 });
+      return;
+    }
+    this.setShapeProps({ hovered: !1 });
+  }
+  triggerDblclick(t) {
+    return !1;
+  }
+  _draw(t) {
+    ct.drawWith(t, {
+      width: this.width,
+      height: this.height,
+      strokeWidth: Sn,
+      stroke: this._color,
+      evented: !1
+    }), this._hovered && (t.save(), t.transform(
+      1,
+      0,
+      0,
+      1,
+      this.width,
+      this._labelPosition === "bottom" ? 0 : -we
+    ), Je.drawWith(t, {
+      text: this._name,
+      color: this._color
+    }), t.restore());
+  }
+}
+var pn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Se = (i, e) => (t, s) => e(t, s, i);
+let Pe = class extends L {
+  constructor(e, t, s, n, r) {
+    super();
+    /** Cursors stored for different Workbooks.  */
+    l(this, "_cursors", /* @__PURE__ */ new Set());
+    l(this, "_lastPointer", null);
+    this._collabCursorController = e, this._univerInstanceService = t, this._renderManagerService = s, this._sheetSkeletonManagerService = n, this._themeService = r, this._init();
+  }
+  _init() {
+    this._sheetSkeletonManagerService.currentSkeleton$.pipe(
+      It(this.dispose$),
+      rs((e) => {
+        if (e) {
+          const t = e.sheetId;
+          return ns(
+            this._collabCursorController.getCollabCursors$(e.unitId),
+            this._themeService.currentTheme$
+          ).pipe(
+            ce(([s, n]) => {
+              const r = /* @__PURE__ */ new Map();
+              return s.forEach((o, a) => {
+                if (o.sheetID === t) {
+                  const c = { ...o };
+                  c.color = n[o.color], r.set(a, c);
+                }
+              }), {
+                skeleton: e,
+                cursors: r
+              };
+            })
+          );
+        }
+        return Te({
+          skeleton: null,
+          cursors: /* @__PURE__ */ new Map()
+        });
+      })
+    ).subscribe(({ skeleton: e, cursors: t }) => {
+      this._removeCollabCursors(), e && this._updateCollabCursors(e, t);
+    }), this._sheetSkeletonManagerService.currentSkeleton$.subscribe((e) => {
+      if (e == null)
+        return;
+      const { unitId: t, skeleton: s } = e, n = this._renderManagerService.getRenderById(t);
+      if (n == null)
+        return;
+      const { scene: r } = n;
+      r.onPointerMoveObserver.add(
+        Et((o) => {
+          var b, G;
+          const { offsetX: a, offsetY: c } = o, { x: h, y: u } = r.getRelativeCoord(
+            $t.FromArray([a, c])
+          ), { scaleX: d, scaleY: f } = r.getAncestorScale(), v = r.getViewport(Ii.VIEW_MAIN), p = r.getScrollXYByRelativeCoords(
+            $t.FromArray([h, u]),
+            v
+          ), E = s.getCellPositionByOffset(
+            a,
+            c,
+            d,
+            f,
+            p
+          );
+          ((b = this._lastPointer) == null ? void 0 : b.column) === E.column && ((G = this._lastPointer) == null ? void 0 : G.row) === E.row || this._cursors.forEach((ue) => {
+            ue.onMouseMove(E);
+          });
+        }, 100)
+      );
+    });
+  }
+  _updateCollabCursors(e, t) {
+    var a;
+    const s = (a = this._sheetSkeletonManagerService.getCurrent()) == null ? void 0 : a.skeleton;
+    if (!s)
+      return;
+    const n = this._getSheetObject();
+    if (!n)
+      return;
+    this._cursors.forEach((c) => {
+      c.makeDirty();
+    });
+    const { scene: r } = n, o = Cn(Array.from(t.values())).map((c) => {
+      const { color: h, range: u, name: d, selection: f, sheetID: v } = c, { startColumn: p, startRow: E, endColumn: b, endRow: G } = u, ue = Pt(E, p, r, s), qe = Pt(G, b, r, s), { columnHeaderHeightAndMarginTop: de } = s, { startX: ge, startY: Ze } = ue, { endX: bs, endY: Ts } = qe, Rs = bs - ge, ys = Ts - Ze, Os = {
+        labelPosition: Ze - de >= we ? "top" : "bottom",
+        sheetID: v,
+        range: u,
+        color: h,
+        name: d,
+        selection: f,
+        left: ge,
+        top: Ze,
+        width: Rs,
+        height: ys,
+        evented: !1
+      };
+      return new vn(d, Os);
+    });
+    r.addObjects(o, fn), this._cursors = new Set(o);
+  }
+  _removeCollabCursors() {
+    var e;
+    (e = this._cursors) == null || e.forEach((t) => t.dispose());
+  }
+  _getSheetObject() {
+    return Ei(this._univerInstanceService, this._renderManagerService);
+  }
+};
+Pe = pn([
+  ee(te.Steady, Pe),
+  Se(0, _(le)),
+  Se(1, k),
+  Se(2, _s),
+  Se(3, _(bi)),
+  Se(4, _(Qt))
+], Pe);
+function Cn(i) {
+  const e = /* @__PURE__ */ new Map();
+  return i.forEach((t) => {
+    if (e.has(t.selection)) {
+      const s = e.get(t.selection);
+      s.name += `, ${t.name}`;
+    } else
+      e.set(t.selection, t);
+  }), Array.from(e.values());
+}
+var A = function() {
+  return A = Object.assign || function(i) {
+    for (var e, t = 1, s = arguments.length; t < s; t++) {
+      e = arguments[t];
+      for (var n in e)
+        Object.prototype.hasOwnProperty.call(e, n) && (i[n] = e[n]);
+    }
+    return i;
+  }, A.apply(this, arguments);
+}, In = function(i, e) {
+  var t = {};
+  for (var s in i)
+    Object.prototype.hasOwnProperty.call(i, s) && e.indexOf(s) < 0 && (t[s] = i[s]);
+  if (i != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var n = 0, s = Object.getOwnPropertySymbols(i); n < s.length; n++)
+      e.indexOf(s[n]) < 0 && Object.prototype.propertyIsEnumerable.call(i, s[n]) && (t[s[n]] = i[s[n]]);
+  return t;
+}, wt = bt(function(i, e) {
+  var t = i.icon, s = i.id, n = i.className, r = i.extend, o = In(i, ["icon", "id", "className", "extend"]), a = "univerjs-icon univerjs-icon-".concat(s, " ").concat(n || "").trim(), c = yi("_".concat(Tn()));
+  return ps(t, "".concat(s), { defIds: t.defIds, idSuffix: c.current }, A({ ref: e, className: a }, o), r);
+});
+function ps(i, e, t, s, n) {
+  return Tt(i.tag, A(A({ key: e }, En(i, t, n)), s), (bn(i, t).children || []).map(function(r, o) {
+    return ps(r, "".concat(e, "-").concat(i.tag, "-").concat(o), t, void 0, n);
+  }));
+}
+function En(i, e, t) {
+  var s = A({}, i.attrs);
+  t != null && t.colorChannel1 && s.fill === "colorChannel1" && (s.fill = t.colorChannel1);
+  var n = e.defIds;
+  return !n || n.length === 0 || (i.tag === "use" && s["xlink:href"] && (s["xlink:href"] = s["xlink:href"] + e.idSuffix), Object.entries(s).forEach(function(r) {
+    var o = r[0], a = r[1];
+    typeof a == "string" && (s[o] = a.replace(/url\(#(.*)\)/, "url(#$1".concat(e.idSuffix, ")")));
+  })), s;
+}
+function bn(i, e) {
+  var t, s = e.defIds;
+  return !s || s.length === 0 ? i : i.tag === "defs" && (!((t = i.children) === null || t === void 0) && t.length) ? A(A({}, i), { children: i.children.map(function(n) {
+    return typeof n.attrs.id == "string" && s && s.indexOf(n.attrs.id) > -1 ? A(A({}, n), { attrs: A(A({}, n.attrs), { id: n.attrs.id + e.idSuffix }) }) : n;
+  }) }) : i;
+}
+function Tn() {
+  return Math.random().toString(36).substring(2, 8);
+}
+wt.displayName = "UniverIcon";
+var Rn = { tag: "svg", attrs: { fill: "none", viewBox: "0 0 16 16", width: "1em", height: "1em" }, children: [{ tag: "mask", attrs: { id: "mask0_102_585", style: { maskType: "alpha" }, width: 16, height: 16, x: 0, y: 0, maskUnits: "userSpaceOnUse" }, children: [{ tag: "path", attrs: { fill: "#D9D9D9", d: "M0 0H16V16H0z" } }] }, { tag: "g", attrs: { fill: "currentColor", mask: "url(#mask0_102_585)" }, children: [{ tag: "path", attrs: { d: "M8.00011 11.7216C7.64665 11.7216 7.36011 11.435 7.36011 11.0816V2.76158C7.36011 2.40812 7.64665 2.12158 8.00011 2.12158 8.35357 2.12158 8.64011 2.40812 8.64011 2.76158V11.0816C8.64011 11.435 8.35357 11.7216 8.00011 11.7216zM8.00008 13.8783C8.46032 13.8783 8.83342 13.5052 8.83342 13.045 8.83342 12.5847 8.46032 12.2116 8.00008 12.2116 7.53985 12.2116 7.16675 12.5847 7.16675 13.045 7.16675 13.5052 7.53985 13.8783 8.00008 13.8783zM9.43991 3.3083V4.6566C11.1747 4.93531 12.8439 5.72115 14.2082 7.01405 14.4754 7.26731 14.8974 7.25598 15.1506 6.98873 15.4039 6.72149 15.3926 6.29953 15.1253 6.04626 13.5035 4.50928 11.5069 3.59665 9.43991 3.3083zM2.3565 6.52137C3.60481 5.51948 5.05771 4.89789 6.55991 4.65657V3.30842C4.7603 3.55961 3.014 4.284 1.52191 5.48155 1.3003 5.65943 1.08439 5.84768.874838 6.04627.607592 6.29953.59626 6.72149.849526 6.98873 1.10279 7.25598 1.52475 7.26731 1.79199 7.01405 1.97498 6.84063 2.16333 6.67643 2.3565 6.52137zM2.86201 8.33667C3.91262 7.28606 5.2049 6.62442 6.55991 6.35175V7.71826C5.55037 7.96981 4.59408 8.49022 3.80482 9.27947 3.54447 9.53982 3.12236 9.53982 2.86201 9.27947 2.60166 9.01912 2.60166 8.59701 2.86201 8.33667zM9.43991 7.71818V6.35169C10.795 6.62431 12.0875 7.28597 13.1382 8.33667 13.3985 8.59701 13.3985 9.01912 13.1382 9.27947 12.8778 9.53982 12.4557 9.53982 12.1953 9.27947 11.406 8.49013 10.4496 7.9697 9.43991 7.71818zM4.86201 10.5082C5.35689 10.0134 5.93957 9.65979 6.55991 9.44753V10.8951C6.28821 11.0374 6.03315 11.2227 5.80482 11.451 5.54447 11.7114 5.12236 11.7114 4.86201 11.451 4.60166 11.1907 4.60166 10.7686 4.86201 10.5082zM9.43991 10.8949V9.44741C10.0604 9.65966 10.6432 10.0133 11.1382 10.5082 11.3985 10.7686 11.3985 11.1907 11.1382 11.451 10.8778 11.7114 10.4557 11.7114 10.1953 11.451 9.96691 11.2226 9.71174 11.0372 9.43991 10.8949z" } }] }] }, Cs = bt(function(i, e) {
+  return Tt(wt, Object.assign({}, i, {
+    id: "off-line-single",
+    ref: e,
+    icon: Rn
+  }));
+});
+Cs.displayName = "OffLineSingle";
+var yn = { tag: "svg", attrs: { fill: "none", viewBox: "0 0 16 16", width: "1em", height: "1em" }, children: [{ tag: "mask", attrs: { id: "mask0_102_580", style: { maskType: "alpha" }, width: 16, height: 16, x: 0, y: 0, maskUnits: "userSpaceOnUse" }, children: [{ tag: "path", attrs: { fill: "#D9D9D9", d: "M0 0H16V16H0z" } }] }, { tag: "g", attrs: { fill: "currentColor", mask: "url(#mask0_102_580)", fillRule: "evenodd", clipRule: "evenodd" }, children: [{ tag: "path", attrs: { d: "M5.82613 4.56746C5.40036 5.04236 5.18674 5.65314 5.02643 6.21425C4.94606 6.49553 4.68897 6.68945 4.39644 6.68945C4.17409 6.68945 3.56092 6.78651 3.0238 7.12221C2.52284 7.43531 2.10324 7.93892 2.10324 8.81885C2.10324 9.60442 2.39454 10.0131 2.72844 10.2503C3.09823 10.5131 3.60322 10.6206 4.06884 10.6206C4.43069 10.6206 4.72404 10.914 4.72404 11.2758C4.72404 11.6377 4.43069 11.931 4.06884 11.931C3.44246 11.931 2.63705 11.7929 1.96945 11.3185C1.26595 10.8187 0.792847 9.99887 0.792847 8.81885C0.792847 7.40558 1.51984 6.5169 2.32929 6.011C2.8676 5.67455 3.44845 5.50028 3.89776 5.42544C4.07573 4.89085 4.35413 4.2463 4.85044 3.69271C5.51609 2.95026 6.5174 2.43066 8.00003 2.43066C9.27898 2.43066 10.2502 2.7993 10.9548 3.3781C11.5184 3.84106 11.881 4.41324 12.1008 4.9709C12.1429 4.98097 12.1875 4.99222 12.2342 5.00477C12.549 5.08928 12.9754 5.23648 13.408 5.48878C14.2932 6.00515 15.2072 6.97409 15.2072 8.65505C15.2072 9.79541 14.8194 10.6501 14.1525 11.2059C13.5065 11.7442 12.6838 11.931 11.9312 11.931C11.5694 11.931 11.276 11.6377 11.276 11.2758C11.276 10.914 11.5694 10.6206 11.9312 10.6206C12.4891 10.6206 12.9767 10.4799 13.3136 10.1992C13.6294 9.93602 13.8968 9.48028 13.8968 8.65505C13.8968 7.55142 13.3367 6.96426 12.7477 6.62068C12.4431 6.443 12.1325 6.33426 11.8944 6.27034C11.7766 6.23871 11.6799 6.21893 11.6151 6.20737C11.5828 6.2016 11.5587 6.19792 11.5442 6.19585L11.53 6.19391L11.5302 6.19393L11.5307 6.19398C11.2667 6.16442 11.0466 5.97834 10.9736 5.72285C10.8382 5.24885 10.5726 4.75996 10.123 4.39067C9.68107 4.02762 9.01427 3.74106 8.00003 3.74106C6.86186 3.74106 6.22518 4.12236 5.82613 4.56746ZM11.53 6.19391L11.5294 6.19384L11.5286 6.19374C11.5284 6.19372 11.5288 6.19377 11.53 6.19391Z" } }, { tag: "path", attrs: { d: "M11.0302 9.12626C11.3127 9.35231 11.3585 9.76463 11.1325 10.0472L8.51171 13.3232C8.40173 13.4606 8.24107 13.5481 8.06592 13.5658C7.89077 13.5835 7.71587 13.5299 7.58063 13.4172L5.61504 11.7792C5.33705 11.5476 5.2995 11.1344 5.53115 10.8564C5.7628 10.5785 6.17595 10.5409 6.45393 10.7725L7.90602 11.9826L10.1093 9.22859C10.3353 8.94603 10.7476 8.90021 11.0302 9.12626Z" } }] }] }, Is = bt(function(i, e) {
+  return Tt(wt, Object.assign({}, i, {
+    id: "on-line-single",
+    ref: e,
+    icon: yn
+  }));
+});
+Is.displayName = "OnLineSingle";
+const On = "univer-online-status-icon", wn = "univer-online-status-title", Mn = "univer-online-status", Dn = "univer-online", Nn = "univer-offline", ve = {
+  onlineStatusIcon: On,
+  onlineStatusTitle: wn,
+  onlineStatus: Mn,
+  online: Dn,
+  offline: Nn
+};
+function An(i) {
+  switch (i) {
+    case w.OFFLINE:
+      return "collabStatus.offline";
+    case w.CONFLICT:
+      return "collabStatus.conflict";
+    case w.FETCH_MISS:
+      return "collabStatus.fetchMiss";
+    case w.NOT_COLLAB:
+      return "collabStatus.notCollab";
+    case w.PENDING:
+    case w.AWAITING:
+    case w.AWAITING_WITH_PENDING:
+      return "collabStatus.syncing";
+    case w.SYNCED:
+      return "collabStatus.synced";
+  }
+}
+function Un(i) {
+  const e = js(i.status$, w.NOT_COLLAB), t = Ti(H), s = e !== w.OFFLINE, n = t.t(An(e)), r = Oi(ve.onlineStatus, {
+    [ve.online]: s,
+    [ve.offline]: !s
+  }), o = s ? /* @__PURE__ */ oe.createElement(Is, null) : /* @__PURE__ */ oe.createElement(Cs, null);
+  return /* @__PURE__ */ oe.createElement("div", { className: r }, /* @__PURE__ */ oe.createElement("div", { className: ve.onlineStatusIcon }, o), /* @__PURE__ */ oe.createElement("div", { className: ve.onlineStatusTitle }, n));
+}
+var kn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Ue = (i, e) => (t, s) => e(t, s, i);
+let xe = class extends X {
+  constructor(e, t, s, n) {
+    super();
+    l(this, "_status$", new U(w.NOT_COLLAB));
+    this._uiController = e, this._univerInstanceService = t, this._injector = s, this._collaborationController = n, this._mountOnlineHint(), this._initStatusListener();
+  }
+  _mountOnlineHint() {
+    this.disposeWithMe(
+      this._uiController.registerComponent(
+        Bs.HEADER_MENU,
+        () => Ri(Ln({ status$: this._status$.asObservable() }), this._injector)
+      )
+    );
+  }
+  _initStatusListener() {
+    this.disposeWithMe(
+      T(
+        this._univerInstanceService.focused$.pipe(
+          ot(() => {
+            const e = this._univerInstanceService.getFocusedUnit();
+            return e ? this._collaborationController.getCollabEntity$(e.getUnitId()) : Te(null);
+          }),
+          ot((e) => e ? e.status$ : Te(w.NOT_COLLAB))
+        ).subscribe((e) => {
+          this._status$.next(e);
+        })
+      )
+    );
+  }
+};
+xe = kn([
+  ee(te.Starting, xe),
+  Ue(0, Vs),
+  Ue(1, k),
+  Ue(2, _(I)),
+  Ue(3, _(Ie))
+], xe);
+function Ln(i) {
+  const { status$: e } = i;
+  return function() {
+    return /* @__PURE__ */ oe.createElement(Un, { status$: e });
+  };
+}
+const Es = pt("uni.network.url-service");
+var $n = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, re = (i, e) => (t, s) => e(t, s, i);
+let Ee = class extends L {
+  constructor(i, e, t, s, n, r) {
+    super(), this._urlService = i, this._logService = e, this._commandService = t, this._localCacheService = s, this._snapshotService = n, r ? r == null || r.whenReady().then(() => this._init()) : (this._logService.debug(
+      "[DataLoaderController]",
+      "No remote instance service injected. May not syncing edits to the web worker."
+    ), this._init());
+  }
+  async _init() {
+    const i = this._urlService.getParam("unit"), e = this._urlService.getParam("type");
+    if (!i || !e) {
+      this._logService.debug(
+        "[DataLoaderController]",
+        "No unitID or type in URL. Will not load files from remote address."
+      );
+      return;
+    }
+    switch (Number(e)) {
+      case x.UNIVER_SHEET: {
+        const t = await this._loadSheet(i);
+        this._setupSubUnitSync(t);
+        break;
+      }
+      case x.UNIVER_DOC: {
+        await this._loadDoc(i);
+        break;
+      }
+      default: {
+        this._logService.error(
+          "[DataLoaderController]",
+          "Unknown type in URL. Will not load files from remote address."
+        );
+        break;
+      }
+    }
+  }
+  async _setupSubUnitSync(i) {
+    await this._updateSubUnitFromURLParams(i), i.activeSheet$.pipe(R(this.dispose$)).subscribe((e) => {
+      e && this._updateURLWithCurrentState(e);
+    }), this._urlService.urlChange$.pipe(R(this.dispose$)).subscribe(() => this._updateSubUnitFromURLParams(i));
+  }
+  _updateURLWithCurrentState(i, e = !1) {
+    const t = this._urlService.getParam("subunit");
+    i.getSheetId() !== t && this._urlService.setParam("subunit", i.getSheetId(), e);
+  }
+  async _updateSubUnitFromURLParams(i) {
+    const e = this._urlService.getParam("subunit");
+    if (!e || !i.getSheetBySheetId(e)) {
+      this._updateURLWithCurrentState(i.getActiveSheet(), !0);
+      return;
+    }
+    i.getActiveSheet().getSheetId() !== e && await this._commandService.executeCommand(fi.id, {
+      unitId: i.getUnitId(),
+      subUnitId: e
+    });
+  }
+  async _loadSheet(i) {
+    let e = 0;
+    const t = await this._localCacheService.loadOfflineData(i);
+    return t && (t.awaitingChangeset || t.mutations.length !== 0) && (e = t.rev), e === 0 && this._logService.debug("[DataLoaderController]", "fetching the latest document from the server."), this._snapshotService.loadSheet(i, e);
+  }
+  async _loadDoc(i) {
+    let e = 0;
+    const t = await this._localCacheService.loadOfflineData(i);
+    return t && (t.awaitingChangeset || t.mutations.length !== 0) && (e = t.rev), e === 0 && this._logService.debug("[DataLoaderController]", "fetching the latest document from the server."), this._snapshotService.loadDoc(i, e);
+  }
+};
+Ee = $n([
+  ee(te.Starting, Ee),
+  re(0, Es),
+  re(1, D),
+  re(2, O),
+  re(3, _(y)),
+  re(4, _(Ws)),
+  re(5, Ye(wi))
+], Ee);
+var Pn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Kt = (i, e) => (t, s) => e(t, s, i);
+const xn = "DEFAULT_FILE_NAME", Hn = "Univer";
+let He = class extends X {
+  constructor(i, e) {
+    super(), this._univerInstanceService = i, this._configService = e, this._init();
+  }
+  _init() {
+    this.disposeWithMe(
+      T(
+        this._univerInstanceService.focused$.subscribe(() => {
+          var t;
+          const i = this._univerInstanceService.getFocusedUnit();
+          let e = (t = this._configService.getConfig(xn)) != null ? t : Hn;
+          i instanceof ks && (e = i.name), document.title = e;
+        })
+      )
+    );
+  }
+};
+He = Pn([
+  ee(te.Ready, He),
+  Kt(0, k),
+  Kt(1, z)
+], He);
+const jn = {
+  collabStatus: {
+    fetchMiss: "正在同步服务端数据...",
+    conflict: "编辑冲突",
+    notCollab: "本地文件",
+    synced: "已保存",
+    syncing: "保存中...",
+    offline: "编辑将在本地保存"
+  },
+  session: {
+    "connection-failed": "连接失败，请检查你的网络",
+    "will-retry": "连接失败，将在一会儿之后重试",
+    "room-full": "协同房间已满，你的编辑将在本地保存",
+    "collaboration-timeout": "服务器未响应你的协同请求，你的编辑将在本地保存"
+  },
+  conflict: {
+    title: "协同冲突",
+    content: "你的本地文档和服务器的文档存在冲突。请在别处保存你的本地编辑，本地编辑将在刷新页面后丢弃。"
+  },
+  collaboration: {
+    "single-unit": {
+      warning: "你在另一个标签页打开了同一个文件。为了避免数据丢失，这个标签页的编辑行为将会被限制。"
+    }
+  },
+  auth: {
+    needGotoLoginAlert: "你的登录已过期，点击确认重新登陆，点击取消去保存你的本地编辑。"
+  }
+}, Bn = jn;
+var Vn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Yt = (i, e) => (t, s) => e(t, s, i);
+const Fn = "SNAPSHOT_SERVER_URL_KEY", Wn = "/universer-api/snapshot";
+let mt = class {
+  constructor(i, e) {
+    this._configService = i, this._httpService = e;
+  }
+  async getUnitOnRev(i, e) {
+    var u;
+    const { unitID: t, type: s, revision: n = 0 } = e, o = `${this._getAPIPrefixPath()}/${s}/unit/${t}/rev/${n === 1 ? 0 : n}`, c = (await this._httpService.get(o)).body, h = (u = c.snapshot) == null ? void 0 : u.workbook;
+    if (h) {
+      const d = h == null ? void 0 : h.originalMeta, f = Mt.encode(Dt(d));
+      h.originalMeta = f, Object.entries(h.sheets).forEach(([, v]) => {
+        const p = v.originalMeta, E = Mt.encode(Dt(p));
+        v.originalMeta = E;
+      });
+    }
+    return c;
+  }
+  async getSheetBlock(i, e) {
+    const { unitID: t, type: s, blockID: n } = e, o = `${this._getAPIPrefixPath()}/${s}/unit/${t}/block/${n}`;
+    return (await this._httpService.get(o)).body;
+  }
+  async fetchMissingChangesets(i, e) {
+    const { unitID: t, type: s, from: n, to: r } = e, a = `${this._getAPIPrefixPath()}/${s}/unit/${t}/fetchmissing?from=${n}&to=${r}`;
+    return (await this._httpService.get(a)).body;
+  }
+  _getAPIPrefixPath() {
+    var i;
+    return (i = this._configService.getConfig(Fn)) != null ? i : Wn;
+  }
+  // #region - server only methods
+  async getResourcesRequest(i, e) {
+    const t = `/universer-api/snapshot/${e.type}/unit/${e.unitID}/resources`;
+    return (await this._httpService.get(t, {
+      params: { resourceId: JSON.stringify(e.resourceIDs) }
+    })).body;
+  }
+  saveSnapshot() {
+    throw new Error("This method should not be called on the client side!");
+  }
+  saveSheetBlock() {
+    throw new Error("This method should not be called on the client side!");
+  }
+  saveChangeset() {
+    throw new Error("This method should not be called on the client side!");
+  }
+  // #endregion - server only methods
+};
+mt = Vn([
+  Yt(0, z),
+  Yt(1, _(Re))
+], mt);
+var Gn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, pe = (i, e) => (t, s) => e(t, s, i);
+let ft = class extends Ls {
+  constructor(i, e, t, s, n) {
+    super(i, e, t), this._transformService = s, this._logService = n;
+  }
+  transformUndoRedo(i, e) {
+    const t = this._getUndoStack(i);
+    if (t)
+      try {
+        const n = this._transformStack(t, e);
+        this._substituteUndoStack(i, n);
+      } catch (n) {
+        this._logService.error("[CollaborationUndoRedoService]", n), this._clearUndo(i);
+      }
+    const s = this._getRedoStack(i);
+    if (s)
+      try {
+        const n = this._transformStack(s, e);
+        this._substituteRedoStack(i, n);
+      } catch (n) {
+        this._logService.error(n), this._clearRedo(i);
+      }
+  }
+  _clearUndo(i) {
+    const e = this._getUndoStack(i);
+    e && (e.length = 0, this._updateStatus());
+  }
+  _clearRedo(i) {
+    const e = this._getRedoStack(i);
+    e && (e.length = 0, this._updateStatus());
+  }
+  _substituteUndoStack(i, e) {
+    this._undoStacks.set(i, e), this._updateStatus();
+  }
+  _substituteRedoStack(i, e) {
+    this._redoStacks.set(i, e), this._updateStatus();
+  }
+  _transformStack(i, e) {
+    const t = [];
+    let s = e, n = e;
+    for (let r = i.length - 1; r >= 0; r--) {
+      const { unitID: o, undoMutations: a, redoMutations: c } = i[r], h = this._transformService.transformMutationsWithChangeset(s, a), u = this._transformService.transformMutationsWithChangeset(n, c);
+      if (At(h) || At(u)) {
+        this._logService.error("[CollaborationUndoRedoService]", "transformStack failed!", h, u);
+        break;
+      }
+      s = h.c1Prime, n = u.c1Prime, t.push({
+        unitID: o,
+        undoMutations: h.m2Prime,
+        redoMutations: u.m2Prime
+      });
+    }
+    return t.reverse();
+  }
+};
+ft = Gn([
+  pe(0, k),
+  pe(1, O),
+  pe(2, $s),
+  pe(3, W),
+  pe(4, D)
+], ft);
+class Kn extends L {
+  constructor() {
+    super();
+    l(this, "urlChange$");
+    this.urlChange$ = ss(window, "popstate").pipe(
+      R(this.dispose$),
+      Ks(1),
+      Ys(void 0)
+    );
+  }
+  setParam(t, s, n = !1) {
+    const r = new URL(window.location.href);
+    r.searchParams.set(t, s), n ? window.history.replaceState("", "", r.toString()) : window.history.pushState("", "", r.toString());
+  }
+  removeParam(t, s = !1) {
+    const n = new URL(window.location.href);
+    n.searchParams.delete(t), s ? window.history.replaceState("", "", n.toString()) : window.history.pushState("", "", n.toString());
+  }
+  getParam(t) {
+    var n;
+    return (n = new URL(window.location.href).searchParams.get(t)) != null ? n : void 0;
+  }
+}
+const st = "collab-text-anchor-", Yn = "collab-text-range-", ke = 6, Xn = 1.5, it = 4, zn = 1.5, Jn = "rgba(255, 255, 255, 0.01)";
+class qn {
+  constructor(e, t, s, n) {
+    l(this, "_shapes", []);
+    l(this, "_anchor", null);
+    l(this, "_textBubble", null);
+    l(this, "_anchorDot", null);
+    l(this, "_hideTimer", null);
+    l(this, "_eventUnsubscribe", null);
+    this._cursor = e, this._scene = t, this._docSkeleton = s, this._document = n, this._render();
+  }
+  // eslint-disable-next-line accessor-pairs
+  set _hover(e) {
+    e ? (this._anchorDot && this._anchorDot.hide(), this._textBubble && this._textBubble.show()) : (this._anchorDot && this._anchorDot.show(), this._textBubble && this._textBubble.hide());
+  }
+  dispose() {
+    for (const e of this._shapes)
+      e.dispose();
+    this._textBubble && this._textBubble.dispose(), this._anchorDot && this._anchorDot.dispose(), this._anchor && this._anchor.dispose(), this._eventUnsubscribe && this._eventUnsubscribe();
+  }
+  _render() {
+    const { _docSkeleton: e, _document: t } = this, { color: s, name: n, ranges: r } = this._cursor, o = t.getOffsetConfig(), { docsLeft: a, docsTop: c } = o, h = new pi(o, e);
+    for (const { startOffset: u, endOffset: d, collapsed: f, isActive: v } of r) {
+      const p = e.findNodePositionByCharIndex(u), E = e.findNodePositionByCharIndex(d);
+      if (v) {
+        const { contentBoxPointGroup: b } = h.getRangePointData(E, E);
+        if (b.length === 0)
+          continue;
+        this._drawAnchor(s, b, a, c, n), this._eventUnsubscribe = this._handleHover();
+      }
+      if (!f) {
+        const { contentBoxPointGroup: b } = h.getRangePointData(p, E);
+        if (b.length === 0)
+          continue;
+        this._drawRange(s, b, a, c);
+      }
+    }
+  }
+  _drawAnchor(e, t, s, n, r) {
+    const o = this._getAnchorBounding(t), { left: a, top: c, height: h } = o, u = this._getScale(), d = zn / u, f = new ct(st + P.generateRandomId(ke), {
+      left: a + s - d,
+      top: c + n,
+      height: h,
+      width: Xn,
+      fill: e || Ne(De.black, 0),
+      strokeWidth: d,
+      stroke: Jn,
+      evented: !0
+    });
+    this._anchor = f, this._scene.addObject(f, Ae);
+    const v = new ct(st + P.generateRandomId(ke), {
+      left: a + s - d,
+      top: c + n - it / 2,
+      height: it,
+      width: it,
+      fill: e || Ne(De.black, 0),
+      strokeWidth: 0,
+      stroke: e || Ne(De.black, 0),
+      evented: !1
+    });
+    this._anchorDot = v, this._scene.addObject(v, Ae);
+    const p = new Je(st + P.generateRandomId(ke), {
+      left: a + s - d,
+      top: c + n - we,
+      text: r,
+      color: e
+    });
+    this._textBubble = p, this._scene.addObject(p, Ae), this._hover = !1;
+  }
+  _handleHover() {
+    const e = this._anchor.onPointerEnterObserver.add(() => {
+      this._hover = !0;
+    }), t = this._anchor.onPointerLeaveObserver.add(() => {
+      this._hideTimer && clearTimeout(this._hideTimer), this._hideTimer = setTimeout(() => {
+        this._hover = !1;
+      }, 2e3);
+    });
+    return () => {
+      var s, n;
+      (s = this._anchor) == null || s.onPointerEnterObserver.remove(e), (n = this._anchor) == null || n.onPointerLeaveObserver.remove(t);
+    };
+  }
+  _drawRange(e, t, s, n) {
+    const o = new Ps(e).setAlpha(0.2).toRgbString(), a = new Ci(Yn + P.generateRandomId(ke), {
+      pointsGroup: t,
+      fill: o || Ne(De.black, 0.2),
+      left: s,
+      top: n,
+      evented: !1,
+      debounceParentDirty: !1
+    });
+    this._shapes.push(a), this._scene.addObject(a, Ae);
+  }
+  _getAnchorBounding(e) {
+    const t = e[0], s = t[0], n = t[2], { x: r, y: o } = s, { x: a, y: c } = n;
+    return {
+      left: r,
+      top: o,
+      width: a - r,
+      height: c - o
+    };
+  }
+  _getScale() {
+    const { scaleX: e, scaleY: t } = this._scene.getAncestorScale();
+    return Math.max(e, t);
+  }
+}
+var Zn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Ce = (i, e) => (t, s) => e(t, s, i);
+let je = class extends L {
+  constructor(e, t, s, n, r) {
+    super();
+    /** Cursors stored for different Workbooks.  */
+    l(this, "_cursors", []);
+    this._collabCursorController = e, this._univerInstanceService = t, this._renderManagerService = s, this._docSkeletonManagerService = n, this._themeService = r, this._init();
+  }
+  _init() {
+    this._docSkeletonManagerService.currentSkeleton$.pipe(
+      It(this.dispose$),
+      rs((e) => {
+        if (e) {
+          const { unitId: t } = e;
+          return ns(
+            this._collabCursorController.getCollabCursors$(t),
+            this._themeService.currentTheme$
+          ).pipe(
+            ce(([s, n]) => ({
+              skeleton: e,
+              cursors: [...s.values()].flatMap((r) => ({ ...r, color: n[r.color] }))
+            }))
+          );
+        }
+        return Te({
+          skeleton: null,
+          cursors: []
+        });
+      })
+    ).subscribe(({ skeleton: e, cursors: t }) => {
+      this._removeCollabCursors(), e && this._updateCollabCursors(e.skeleton, t);
+    });
+  }
+  _updateCollabCursors(e, t) {
+    const s = this._getDocObject();
+    if (s == null)
+      return;
+    const { scene: n, document: r } = s, o = t.map((a) => new qn(a, n, e, r));
+    this._cursors = o;
+  }
+  _removeCollabCursors() {
+    this._cursors.forEach((e) => e.dispose()), this._cursors = [];
+  }
+  _getDocObject() {
+    return Qs(this._univerInstanceService, this._renderManagerService);
+  }
+};
+je = Zn([
+  ee(te.Steady, je),
+  Ce(0, _(le)),
+  Ce(1, k),
+  Ce(2, _s),
+  Ce(3, _(ei)),
+  Ce(4, _(Qt))
+], je);
+var Qn = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, nt = (i, e) => (t, s) => e(t, s, i);
+const er = "LOGIN_URL_KEY", tr = "/universer-api/oidc/authpage";
+let Ge = class {
+  constructor(i, e, t) {
+    this._configService = i, this._httpService = e, this.localeService = t, this.init();
+  }
+  init() {
+    this._httpService.registerHTTPInterceptor({
+      priority: 1,
+      interceptor: (i, e) => e(i).pipe(
+        Xs(async (t) => {
+          if (t.status === 401 && window.confirm(
+            this.localeService.t("auth.needGotoLoginAlert")
+          )) {
+            const n = window.encodeURIComponent(window.location.href);
+            window.location.href = `${this._getLoginPath()}?url=${n}`;
+          }
+          return t;
+        })
+      )
+    });
+  }
+  _getLoginPath() {
+    var i;
+    return (i = this._configService.getConfig(er)) != null ? i : tr;
+  }
+};
+Ge = Qn([
+  nt(0, z),
+  nt(1, _(Re)),
+  nt(2, _(H))
+], Ge);
+var sr = (i, e, t, s) => {
+  for (var n = e, r = i.length - 1, o; r >= 0; r--)
+    (o = i[r]) && (n = o(n) || n);
+  return n;
+}, Xt = (i, e) => (t, s) => e(t, s, i);
+const ir = "collaboration-client";
+var rt;
+let zt = (rt = class extends xs {
+  constructor(i, e, t) {
+    super(), this._config = i, this._injector = e, this._localeService = t, this._localeService.load({ zhCN: Bn });
+  }
+  onStarting(i) {
+    var s, n, r, o;
+    i.replace([J, { useClass: ft }]);
+    const e = [
+      // services
+      [ye],
+      [Ot],
+      [Re],
+      [Es, { useClass: Kn }],
+      [Z],
+      [y],
+      [cs],
+      [Fe],
+      [Ve],
+      [Be],
+      [yt],
+      [Ge],
+      // abstract services
+      [us, { useClass: (n = (s = this._config) == null ? void 0 : s.socketService) != null ? n : ht }],
+      [ti, { useClass: si }],
+      [qt, { useClass: mt }],
+      // controllers
+      [Ie],
+      [Ee],
+      [xe],
+      [He],
+      [le]
+    ];
+    (r = this._config) != null && r.enableSingleActiveInstanceLock && e.push([Xe, { useClass: zi }]), ((o = this._config) == null ? void 0 : o.collaborationUniverTypes) == null || this._config.collaborationUniverTypes.includes(M.UNIVER_SHEET) ? e.push([Pe]) : this._config.collaborationUniverTypes.includes(M.UNIVER_DOC) && e.push([je]), e.forEach((a) => i.add(a)), i.get(Re).registerHTTPInterceptor({
+      priority: 20,
+      interceptor: i.invoke(ii, { maxParallel: 6 })
+    }), this._initModules();
+  }
+  _initModules() {
+    var i, e;
+    this._injector.get(Ee), (i = this._config) != null && i.enableOfflineEditing || this._injector.get(y).disableLocalCache(), (e = this._config) != null && e.enableAuthServer && this._injector.get(Ge);
+  }
+}, l(rt, "pluginName", ir), rt);
+zt = sr([
+  Xt(1, _(I)),
+  Xt(2, _(H))
+], zt);
+const nr = {
+  collabStatus: {
+    fetchMiss: "Syncing server data...",
+    conflict: "Edit conflicts",
+    notCollab: "Local file",
+    synced: "Synced",
+    syncing: "Syncing...",
+    offline: "Offline, edits would be save on local"
+  },
+  session: {
+    "connection-failed": "Connection failed, please check your network.",
+    "will-retry": "Connection failed, we retry in a while.",
+    "room-full": "Collaboration room is full. You edits would be saved locally.",
+    "collaboration-timeout": "The server is not responding to your collaboration request. Your edits would be saved locally."
+  },
+  conflict: {
+    title: "Collaboration Conflict",
+    content: "There is a conflict between your local copy and the copy on the server. Please save your local edits, because they will be lost when you reload the page."
+  },
+  collaboration: {
+    "single-unit": {
+      warning: "You opened the same file in another tab. In case of data missing, you cannot edit on this tab."
+    }
+  },
+  auth: {
+    needGotoLoginAlert: "Your login has expired, click OK to re-login, click Cancel to save your local edits."
+  }
+}, Tr = nr;
+export {
+  Li as COLLAB_SUBMIT_CHANGESET_URL_KEY,
+  xi as COLLAB_WEB_SOCKET_URL_KEY,
+  zt as CollaborationClientPlugin,
+  Ie as CollaborationController,
+  lt as CollaborationSession,
+  ye as CollaborationSessionService,
+  ht as CollaborationSocketService,
+  ji as HEARTBEAT_INTERVAL_KEY,
+  gs as HEARTBEAT_TIMEOUT_KEY,
+  us as ICollaborationSocketService,
+  Yi as LOCAL_CACHE_INTERVAL_KEY,
+  er as LOGIN_URL_KEY,
+  nn as SEND_CHANGESET_TIMEOUT_KEY,
+  Fn as SNAPSHOT_SERVER_URL_KEY,
+  he as SessionStatus,
+  Ai as deserializeToCombResponse,
+  Tr as enUS,
+  Ui as serializeCombRequest,
+  Bn as zhCN
+};