@univerjs/rpc 0.1.0-alpha.1 → 0.1.0-alpha.2

package/lib/es/index.js

@@ -0,0 +1,1258 @@
+var Ee = Object.defineProperty;
+var xe = (t, r, e) => r in t ? Ee(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
+var d = (t, r, e) => (xe(t, typeof r != "symbol" ? r + "" : r, e), e);
+import { DocumentType as ae, ICommandService as M, IUniverInstanceService as ue, RxDisposable as z, OnLifecycle as le, LifecycleStages as fe, CommandType as he, Disposable as Oe, Plugin as pe, PluginType as de } from "@univerjs/core";
+import { createIdentifier as B, Inject as q, Injector as A } from "@wendellhu/redi";
+import { BehaviorSubject as Te, firstValueFrom as Me, Observable as J, isObservable as qe, of as Ae, shareReplay as ye } from "rxjs";
+function h(t) {
+  return typeof t == "function";
+}
+function Ue(t) {
+  return h(t == null ? void 0 : t.lift);
+}
+function Q(t) {
+  return function(r) {
+    if (Ue(r))
+      return r.lift(function(e) {
+        try {
+          return t(e, this);
+        } catch (n) {
+          this.error(n);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+var F = function(t, r) {
+  return F = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, n) {
+    e.__proto__ = n;
+  } || function(e, n) {
+    for (var s in n)
+      Object.prototype.hasOwnProperty.call(n, s) && (e[s] = n[s]);
+  }, F(t, r);
+};
+function X(t, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+  F(t, r);
+  function e() {
+    this.constructor = t;
+  }
+  t.prototype = r === null ? Object.create(r) : (e.prototype = r.prototype, new e());
+}
+function je(t, r, e, n) {
+  function s(i) {
+    return i instanceof e ? i : new e(function(o) {
+      o(i);
+    });
+  }
+  return new (e || (e = Promise))(function(i, o) {
+    function a(l) {
+      try {
+        c(n.next(l));
+      } catch (v) {
+        o(v);
+      }
+    }
+    function u(l) {
+      try {
+        c(n.throw(l));
+      } catch (v) {
+        o(v);
+      }
+    }
+    function c(l) {
+      l.done ? i(l.value) : s(l.value).then(a, u);
+    }
+    c((n = n.apply(t, r || [])).next());
+  });
+}
+function ve(t, r) {
+  var e = { label: 0, sent: function() {
+    if (i[0] & 1)
+      throw i[1];
+    return i[1];
+  }, trys: [], ops: [] }, n, s, i, o;
+  return o = { next: a(0), throw: a(1), return: a(2) }, typeof Symbol == "function" && (o[Symbol.iterator] = function() {
+    return this;
+  }), o;
+  function a(c) {
+    return function(l) {
+      return u([c, l]);
+    };
+  }
+  function u(c) {
+    if (n)
+      throw new TypeError("Generator is already executing.");
+    for (; o && (o = 0, c[0] && (e = 0)), e; )
+      try {
+        if (n = 1, s && (i = c[0] & 2 ? s.return : c[0] ? s.throw || ((i = s.return) && i.call(s), 0) : s.next) && !(i = i.call(s, c[1])).done)
+          return i;
+        switch (s = 0, i && (c = [c[0] & 2, i.value]), c[0]) {
+          case 0:
+          case 1:
+            i = c;
+            break;
+          case 4:
+            return e.label++, { value: c[1], done: !1 };
+          case 5:
+            e.label++, s = c[1], c = [0];
+            continue;
+          case 7:
+            c = e.ops.pop(), e.trys.pop();
+            continue;
+          default:
+            if (i = e.trys, !(i = i.length > 0 && i[i.length - 1]) && (c[0] === 6 || c[0] === 2)) {
+              e = 0;
+              continue;
+            }
+            if (c[0] === 3 && (!i || c[1] > i[0] && c[1] < i[3])) {
+              e.label = c[1];
+              break;
+            }
+            if (c[0] === 6 && e.label < i[1]) {
+              e.label = i[1], i = c;
+              break;
+            }
+            if (i && e.label < i[2]) {
+              e.label = i[2], e.ops.push(c);
+              break;
+            }
+            i[2] && e.ops.pop(), e.trys.pop();
+            continue;
+        }
+        c = r.call(t, e);
+      } catch (l) {
+        c = [6, l], s = 0;
+      } finally {
+        n = i = 0;
+      }
+    if (c[0] & 5)
+      throw c[1];
+    return { value: c[0] ? c[1] : void 0, done: !0 };
+  }
+}
+function P(t) {
+  var r = typeof Symbol == "function" && Symbol.iterator, e = r && t[r], n = 0;
+  if (e)
+    return e.call(t);
+  if (t && typeof t.length == "number")
+    return {
+      next: function() {
+        return t && n >= t.length && (t = void 0), { value: t && t[n++], done: !t };
+      }
+    };
+  throw new TypeError(r ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function C(t, r) {
+  var e = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!e)
+    return t;
+  var n = e.call(t), s, i = [], o;
+  try {
+    for (; (r === void 0 || r-- > 0) && !(s = n.next()).done; )
+      i.push(s.value);
+  } catch (a) {
+    o = { error: a };
+  } finally {
+    try {
+      s && !s.done && (e = n.return) && e.call(n);
+    } finally {
+      if (o)
+        throw o.error;
+    }
+  }
+  return i;
+}
+function E(t, r, e) {
+  if (e || arguments.length === 2)
+    for (var n = 0, s = r.length, i; n < s; n++)
+      (i || !(n in r)) && (i || (i = Array.prototype.slice.call(r, 0, n)), i[n] = r[n]);
+  return t.concat(i || Array.prototype.slice.call(r));
+}
+function m(t) {
+  return this instanceof m ? (this.v = t, this) : new m(t);
+}
+function $e(t, r, e) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = e.apply(t, r || []), s, i = [];
+  return s = {}, o("next"), o("throw"), o("return"), s[Symbol.asyncIterator] = function() {
+    return this;
+  }, s;
+  function o(f) {
+    n[f] && (s[f] = function(y) {
+      return new Promise(function(_, p) {
+        i.push([f, y, _, p]) > 1 || a(f, y);
+      });
+    });
+  }
+  function a(f, y) {
+    try {
+      u(n[f](y));
+    } catch (_) {
+      v(i[0][3], _);
+    }
+  }
+  function u(f) {
+    f.value instanceof m ? Promise.resolve(f.value.v).then(c, l) : v(i[0][2], f);
+  }
+  function c(f) {
+    a("next", f);
+  }
+  function l(f) {
+    a("throw", f);
+  }
+  function v(f, y) {
+    f(y), i.shift(), i.length && a(i[0][0], i[0][1]);
+  }
+}
+function De(t) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var r = t[Symbol.asyncIterator], e;
+  return r ? r.call(t) : (t = typeof P == "function" ? P(t) : t[Symbol.iterator](), e = {}, n("next"), n("throw"), n("return"), e[Symbol.asyncIterator] = function() {
+    return this;
+  }, e);
+  function n(i) {
+    e[i] = t[i] && function(o) {
+      return new Promise(function(a, u) {
+        o = t[i](o), s(a, u, o.done, o.value);
+      });
+    };
+  }
+  function s(i, o, a, u) {
+    Promise.resolve(u).then(function(c) {
+      i({ value: c, done: a });
+    }, o);
+  }
+}
+var Le = function(t) {
+  return t && typeof t.length == "number" && typeof t != "function";
+};
+function Fe(t) {
+  return h(t == null ? void 0 : t.then);
+}
+function ke(t) {
+  var r = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, e = t(r);
+  return e.prototype = Object.create(Error.prototype), e.prototype.constructor = e, e;
+}
+var j = ke(function(t) {
+  return function(e) {
+    t(this), this.message = e ? e.length + ` errors occurred during unsubscription:
+` + e.map(function(n, s) {
+      return s + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = e;
+  };
+});
+function ne(t, r) {
+  if (t) {
+    var e = t.indexOf(r);
+    0 <= e && t.splice(e, 1);
+  }
+}
+var Z = function() {
+  function t(r) {
+    this.initialTeardown = r, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return t.prototype.unsubscribe = function() {
+    var r, e, n, s, i;
+    if (!this.closed) {
+      this.closed = !0;
+      var o = this._parentage;
+      if (o)
+        if (this._parentage = null, Array.isArray(o))
+          try {
+            for (var a = P(o), u = a.next(); !u.done; u = a.next()) {
+              var c = u.value;
+              c.remove(this);
+            }
+          } catch (p) {
+            r = { error: p };
+          } finally {
+            try {
+              u && !u.done && (e = a.return) && e.call(a);
+            } finally {
+              if (r)
+                throw r.error;
+            }
+          }
+        else
+          o.remove(this);
+      var l = this.initialTeardown;
+      if (h(l))
+        try {
+          l();
+        } catch (p) {
+          i = p instanceof j ? p.errors : [p];
+        }
+      var v = this._finalizers;
+      if (v) {
+        this._finalizers = null;
+        try {
+          for (var f = P(v), y = f.next(); !y.done; y = f.next()) {
+            var _ = y.value;
+            try {
+              ie(_);
+            } catch (p) {
+              i = i ?? [], p instanceof j ? i = E(E([], C(i)), C(p.errors)) : i.push(p);
+            }
+          }
+        } catch (p) {
+          n = { error: p };
+        } finally {
+          try {
+            y && !y.done && (s = f.return) && s.call(f);
+          } finally {
+            if (n)
+              throw n.error;
+          }
+        }
+      }
+      if (i)
+        throw new j(i);
+    }
+  }, t.prototype.add = function(r) {
+    var e;
+    if (r && r !== this)
+      if (this.closed)
+        ie(r);
+      else {
+        if (r instanceof t) {
+          if (r.closed || r._hasParent(this))
+            return;
+          r._addParent(this);
+        }
+        (this._finalizers = (e = this._finalizers) !== null && e !== void 0 ? e : []).push(r);
+      }
+  }, t.prototype._hasParent = function(r) {
+    var e = this._parentage;
+    return e === r || Array.isArray(e) && e.includes(r);
+  }, t.prototype._addParent = function(r) {
+    var e = this._parentage;
+    this._parentage = Array.isArray(e) ? (e.push(r), e) : e ? [e, r] : r;
+  }, t.prototype._removeParent = function(r) {
+    var e = this._parentage;
+    e === r ? this._parentage = null : Array.isArray(e) && ne(e, r);
+  }, t.prototype.remove = function(r) {
+    var e = this._finalizers;
+    e && ne(e, r), r instanceof t && r._removeParent(this);
+  }, t.EMPTY = function() {
+    var r = new t();
+    return r.closed = !0, r;
+  }(), t;
+}();
+Z.EMPTY;
+function be(t) {
+  return t instanceof Z || t && "closed" in t && h(t.remove) && h(t.add) && h(t.unsubscribe);
+}
+function ie(t) {
+  h(t) ? t() : t.unsubscribe();
+}
+var me = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, k = {
+  setTimeout: function(t, r) {
+    for (var e = [], n = 2; n < arguments.length; n++)
+      e[n - 2] = arguments[n];
+    var s = k.delegate;
+    return s != null && s.setTimeout ? s.setTimeout.apply(s, E([t, r], C(e))) : setTimeout.apply(void 0, E([t, r], C(e)));
+  },
+  clearTimeout: function(t) {
+    var r = k.delegate;
+    return ((r == null ? void 0 : r.clearTimeout) || clearTimeout)(t);
+  },
+  delegate: void 0
+};
+function _e(t) {
+  k.setTimeout(function() {
+    throw t;
+  });
+}
+function W() {
+}
+function We(t) {
+  t();
+}
+var K = function(t) {
+  X(r, t);
+  function r(e) {
+    var n = t.call(this) || this;
+    return n.isStopped = !1, e ? (n.destination = e, be(e) && e.add(n)) : n.destination = Ve, n;
+  }
+  return r.create = function(e, n, s) {
+    return new H(e, n, s);
+  }, r.prototype.next = function(e) {
+    this.isStopped || this._next(e);
+  }, r.prototype.error = function(e) {
+    this.isStopped || (this.isStopped = !0, this._error(e));
+  }, r.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, r.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, t.prototype.unsubscribe.call(this), this.destination = null);
+  }, r.prototype._next = function(e) {
+    this.destination.next(e);
+  }, r.prototype._error = function(e) {
+    try {
+      this.destination.error(e);
+    } finally {
+      this.unsubscribe();
+    }
+  }, r.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, r;
+}(Z), He = Function.prototype.bind;
+function $(t, r) {
+  return He.call(t, r);
+}
+var Ge = function() {
+  function t(r) {
+    this.partialObserver = r;
+  }
+  return t.prototype.next = function(r) {
+    var e = this.partialObserver;
+    if (e.next)
+      try {
+        e.next(r);
+      } catch (n) {
+        R(n);
+      }
+  }, t.prototype.error = function(r) {
+    var e = this.partialObserver;
+    if (e.error)
+      try {
+        e.error(r);
+      } catch (n) {
+        R(n);
+      }
+    else
+      R(r);
+  }, t.prototype.complete = function() {
+    var r = this.partialObserver;
+    if (r.complete)
+      try {
+        r.complete();
+      } catch (e) {
+        R(e);
+      }
+  }, t;
+}(), H = function(t) {
+  X(r, t);
+  function r(e, n, s) {
+    var i = t.call(this) || this, o;
+    if (h(e) || !e)
+      o = {
+        next: e ?? void 0,
+        error: n ?? void 0,
+        complete: s ?? void 0
+      };
+    else {
+      var a;
+      i && me.useDeprecatedNextContext ? (a = Object.create(e), a.unsubscribe = function() {
+        return i.unsubscribe();
+      }, o = {
+        next: e.next && $(e.next, a),
+        error: e.error && $(e.error, a),
+        complete: e.complete && $(e.complete, a)
+      }) : o = e;
+    }
+    return i.destination = new Ge(o), i;
+  }
+  return r;
+}(K);
+function R(t) {
+  _e(t);
+}
+function Ye(t) {
+  throw t;
+}
+var Ve = {
+  closed: !0,
+  next: W,
+  error: Ye,
+  complete: W
+}, N = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function ze(t) {
+  return t;
+}
+function Be(t) {
+  return t.length === 0 ? ze : t.length === 1 ? t[0] : function(e) {
+    return t.reduce(function(n, s) {
+      return s(n);
+    }, e);
+  };
+}
+var b = function() {
+  function t(r) {
+    r && (this._subscribe = r);
+  }
+  return t.prototype.lift = function(r) {
+    var e = new t();
+    return e.source = this, e.operator = r, e;
+  }, t.prototype.subscribe = function(r, e, n) {
+    var s = this, i = Qe(r) ? r : new H(r, e, n);
+    return We(function() {
+      var o = s, a = o.operator, u = o.source;
+      i.add(a ? a.call(i, u) : u ? s._subscribe(i) : s._trySubscribe(i));
+    }), i;
+  }, t.prototype._trySubscribe = function(r) {
+    try {
+      return this._subscribe(r);
+    } catch (e) {
+      r.error(e);
+    }
+  }, t.prototype.forEach = function(r, e) {
+    var n = this;
+    return e = se(e), new e(function(s, i) {
+      var o = new H({
+        next: function(a) {
+          try {
+            r(a);
+          } catch (u) {
+            i(u), o.unsubscribe();
+          }
+        },
+        error: i,
+        complete: s
+      });
+      n.subscribe(o);
+    });
+  }, t.prototype._subscribe = function(r) {
+    var e;
+    return (e = this.source) === null || e === void 0 ? void 0 : e.subscribe(r);
+  }, t.prototype[N] = function() {
+    return this;
+  }, t.prototype.pipe = function() {
+    for (var r = [], e = 0; e < arguments.length; e++)
+      r[e] = arguments[e];
+    return Be(r)(this);
+  }, t.prototype.toPromise = function(r) {
+    var e = this;
+    return r = se(r), new r(function(n, s) {
+      var i;
+      e.subscribe(function(o) {
+        return i = o;
+      }, function(o) {
+        return s(o);
+      }, function() {
+        return n(i);
+      });
+    });
+  }, t.create = function(r) {
+    return new t(r);
+  }, t;
+}();
+function se(t) {
+  var r;
+  return (r = t ?? me.Promise) !== null && r !== void 0 ? r : Promise;
+}
+function Je(t) {
+  return t && h(t.next) && h(t.error) && h(t.complete);
+}
+function Qe(t) {
+  return t && t instanceof K || Je(t) && be(t);
+}
+function Xe(t) {
+  return h(t[N]);
+}
+function Ze(t) {
+  return Symbol.asyncIterator && h(t == null ? void 0 : t[Symbol.asyncIterator]);
+}
+function Ke(t) {
+  return new TypeError("You provided " + (t !== null && typeof t == "object" ? "an invalid object" : "'" + t + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function Ne() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var et = Ne();
+function tt(t) {
+  return h(t == null ? void 0 : t[et]);
+}
+function rt(t) {
+  return $e(this, arguments, function() {
+    var e, n, s, i;
+    return ve(this, function(o) {
+      switch (o.label) {
+        case 0:
+          e = t.getReader(), o.label = 1;
+        case 1:
+          o.trys.push([1, , 9, 10]), o.label = 2;
+        case 2:
+          return [4, m(e.read())];
+        case 3:
+          return n = o.sent(), s = n.value, i = n.done, i ? [4, m(void 0)] : [3, 5];
+        case 4:
+          return [2, o.sent()];
+        case 5:
+          return [4, m(s)];
+        case 6:
+          return [4, o.sent()];
+        case 7:
+          return o.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return e.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function nt(t) {
+  return h(t == null ? void 0 : t.getReader);
+}
+function it(t) {
+  if (t instanceof b)
+    return t;
+  if (t != null) {
+    if (Xe(t))
+      return st(t);
+    if (Le(t))
+      return ot(t);
+    if (Fe(t))
+      return ct(t);
+    if (Ze(t))
+      return Se(t);
+    if (tt(t))
+      return at(t);
+    if (nt(t))
+      return ut(t);
+  }
+  throw Ke(t);
+}
+function st(t) {
+  return new b(function(r) {
+    var e = t[N]();
+    if (h(e.subscribe))
+      return e.subscribe(r);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function ot(t) {
+  return new b(function(r) {
+    for (var e = 0; e < t.length && !r.closed; e++)
+      r.next(t[e]);
+    r.complete();
+  });
+}
+function ct(t) {
+  return new b(function(r) {
+    t.then(function(e) {
+      r.closed || (r.next(e), r.complete());
+    }, function(e) {
+      return r.error(e);
+    }).then(null, _e);
+  });
+}
+function at(t) {
+  return new b(function(r) {
+    var e, n;
+    try {
+      for (var s = P(t), i = s.next(); !i.done; i = s.next()) {
+        var o = i.value;
+        if (r.next(o), r.closed)
+          return;
+      }
+    } catch (a) {
+      e = { error: a };
+    } finally {
+      try {
+        i && !i.done && (n = s.return) && n.call(s);
+      } finally {
+        if (e)
+          throw e.error;
+      }
+    }
+    r.complete();
+  });
+}
+function Se(t) {
+  return new b(function(r) {
+    lt(t, r).catch(function(e) {
+      return r.error(e);
+    });
+  });
+}
+function ut(t) {
+  return Se(rt(t));
+}
+function lt(t, r) {
+  var e, n, s, i;
+  return je(this, void 0, void 0, function() {
+    var o, a;
+    return ve(this, function(u) {
+      switch (u.label) {
+        case 0:
+          u.trys.push([0, 5, 6, 11]), e = De(t), u.label = 1;
+        case 1:
+          return [4, e.next()];
+        case 2:
+          if (n = u.sent(), !!n.done)
+            return [3, 4];
+          if (o = n.value, r.next(o), r.closed)
+            return [2];
+          u.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return a = u.sent(), s = { error: a }, [3, 11];
+        case 6:
+          return u.trys.push([6, , 9, 10]), n && !n.done && (i = e.return) ? [4, i.call(e)] : [3, 8];
+        case 7:
+          u.sent(), u.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (s)
+            throw s.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return r.complete(), [2];
+      }
+    });
+  });
+}
+function ee(t, r, e, n, s) {
+  return new ft(t, r, e, n, s);
+}
+var ft = function(t) {
+  X(r, t);
+  function r(e, n, s, i, o, a) {
+    var u = t.call(this, e) || this;
+    return u.onFinalize = o, u.shouldUnsubscribe = a, u._next = n ? function(c) {
+      try {
+        n(c);
+      } catch (l) {
+        e.error(l);
+      }
+    } : t.prototype._next, u._error = i ? function(c) {
+      try {
+        i(c);
+      } catch (l) {
+        e.error(l);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._error, u._complete = s ? function() {
+      try {
+        s();
+      } catch (c) {
+        e.error(c);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._complete, u;
+  }
+  return r.prototype.unsubscribe = function() {
+    var e;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var n = this.closed;
+      t.prototype.unsubscribe.call(this), !n && ((e = this.onFinalize) === null || e === void 0 || e.call(this));
+    }
+  }, r;
+}(K), ht = new b(function(t) {
+  return t.complete();
+});
+function pt(t) {
+  return t <= 0 ? function() {
+    return ht;
+  } : Q(function(r, e) {
+    var n = 0;
+    r.subscribe(ee(e, function(s) {
+      ++n <= t && (e.next(s), t <= n && e.complete());
+    }));
+  });
+}
+function dt(t, r) {
+  return Q(function(e, n) {
+    var s = 0;
+    e.subscribe(ee(n, function(i) {
+      return t.call(r, i, s++) && n.next(i);
+    }));
+  });
+}
+function x(t) {
+  return Q(function(r, e) {
+    it(t).subscribe(ee(e, function() {
+      return e.complete();
+    }, W)), !e.closed && r.subscribe(e);
+  });
+}
+var yt = Object.defineProperty, vt = Object.getOwnPropertyDescriptor, we = (t, r, e, n) => {
+  for (var s = n > 1 ? void 0 : n ? vt(r, e) : r, i = t.length - 1, o; i >= 0; i--)
+    (o = t[i]) && (s = (n ? o(r, e, s) : o(s)) || s);
+  return n && s && yt(r, e, s), s;
+}, G = (t, r) => (e, n) => r(e, n, t);
+const te = "univer.remote-sync-service", O = B(te);
+let Y = class {
+  constructor(t) {
+    this._commandService = t;
+  }
+  async syncMutation(t) {
+    return this._commandService.syncExecuteCommand(t.mutationInfo.id, t.mutationInfo.params, {
+      local: !0,
+      fromSync: !0
+    });
+  }
+};
+Y = we([
+  G(0, M)
+], Y);
+const re = "univer.remote-instance-service", T = B(re);
+let V = class {
+  constructor(t, r) {
+    this._univerInstanceService = t, this._commandService = r;
+  }
+  async syncMutation(t) {
+    return this._commandService.syncExecuteCommand(t.mutationInfo.id, t.mutationInfo.params, {
+      local: !0,
+      fromSync: !0
+    });
+  }
+  async createInstance(t) {
+    const { type: r, snapshot: e } = t;
+    try {
+      switch (r) {
+        case ae.SHEET:
+          return !!this._univerInstanceService.createSheet(e);
+        default:
+          throw new Error(
+            `[RemoteInstanceReplicaService]: cannot create replica for document type: ${r}.`
+          );
+      }
+    } catch (n) {
+      throw n instanceof Error ? n : new Error(`${n}`);
+    }
+  }
+  async disposeInstance(t) {
+    return this._univerInstanceService.disposeDocument(t.unitID);
+  }
+};
+V = we([
+  G(0, ue),
+  G(1, M)
+], V);
+function ge(t) {
+  const r = t;
+  return new class {
+    call(e, n) {
+      const s = r[e];
+      if (typeof s == "function") {
+        let i = s.apply(r, [n]);
+        return i instanceof Promise || (i = Promise.resolve(i)), i;
+      }
+      throw new Error(`[RPC]: method not found for ${e}!`);
+    }
+    subscribe(e, n) {
+      const s = r[e];
+      if (typeof s == "function") {
+        const i = s.apply(r, n);
+        return qe(i) ? i : Ae(i);
+      }
+      throw new Error(`[RPC]: observable method not found for ${e}!`);
+    }
+  }();
+}
+function Pe(t) {
+  return new Proxy({}, {
+    get(r, e) {
+      return function(...n) {
+        return bt(e) ? t.subscribe(e, n[0]) : t.call(e, n[0]);
+      };
+    }
+  });
+}
+function bt(t) {
+  return t.endsWith("$");
+}
+class mt extends z {
+  constructor(e) {
+    super();
+    d(this, "_initialized", new Te(!1));
+    d(this, "_lastRequestCounter", 0);
+    d(this, "_pendingRequests", /* @__PURE__ */ new Map());
+    d(this, "_pendingSubscriptions", /* @__PURE__ */ new Map());
+    this._protocol = e, this._protocol.onMessage.pipe(x(this.dispose$)).subscribe((n) => this._onResponse(n));
+  }
+  getChannel(e) {
+    const n = this;
+    return {
+      call(s, i) {
+        return n._disposed ? Promise.reject() : n._remoteCall(e, s, i);
+      },
+      subscribe(s, i) {
+        if (n._disposed)
+          throw new Error("[ChannelClient]: client is disposed!");
+        return n._remoteSubscribe(e, s, i);
+      }
+    };
+  }
+  _whenReady() {
+    return Me(
+      this._initialized.pipe(
+        dt((e) => e),
+        pt(1)
+      )
+    );
+  }
+  async _remoteCall(e, n, s) {
+    await this._whenReady();
+    const i = ++this._lastRequestCounter, a = { seq: i, type: 100, channelName: e, method: n, args: s }, u = this;
+    return new Promise((c, l) => {
+      const v = {
+        handle(f) {
+          switch (f.type) {
+            case 100:
+              u._pendingRequests.delete(i), c(f.data);
+              break;
+            case 101:
+              u._pendingRequests.delete(i), l(f.data);
+              break;
+            default:
+              throw new Error("[ChannelClient]: unknown response type!");
+          }
+        }
+      };
+      this._pendingRequests.set(i, v), this._sendRequest(a);
+    });
+  }
+  _remoteSubscribe(e, n, s) {
+    return new J((i) => {
+      let o = -1;
+      return this._whenReady().then(() => {
+        o = ++this._lastRequestCounter;
+        const u = { seq: o, type: 101, channelName: e, method: n, args: s }, c = {
+          handle(l) {
+            switch (l.type) {
+              case 200:
+                i.next(l.data);
+                break;
+              case 201:
+                i.error(l.data);
+                break;
+              case 202:
+                i.complete();
+                break;
+              default:
+                throw new Error("[ChannelClient]: unknown response type!");
+            }
+          }
+        };
+        this._pendingRequests.set(o, c), this._sendRequest(u);
+      }), () => {
+        if (o === -1)
+          return;
+        const a = {
+          type: 102,
+          seq: o,
+          channelName: e,
+          method: n
+        };
+        this._sendRequest(a);
+      };
+    });
+  }
+  _sendRequest(e) {
+    this._protocol.send(e);
+  }
+  _onResponse(e) {
+    var n;
+    switch (e.type) {
+      case 0:
+        this._initialized.next(!0);
+        break;
+      case 100:
+      case 101:
+      case 200:
+      case 202:
+      case 201:
+        (n = this._pendingRequests.get(e.seq)) == null || n.handle(e);
+        break;
+    }
+  }
+}
+class _t extends z {
+  constructor(e) {
+    super();
+    d(this, "_channels", /* @__PURE__ */ new Map());
+    d(this, "_subscriptions", /* @__PURE__ */ new Map());
+    this._protocol = e, this._protocol.onMessage.pipe(x(this.dispose$)).subscribe((n) => this._onRequest(n)), this._sendResponse({
+      seq: -1,
+      type: 0
+      /* INITIALIZE */
+    });
+  }
+  registerChannel(e, n) {
+    this._channels.set(e, n);
+  }
+  _onRequest(e) {
+    switch (e.type) {
+      case 100:
+        this._onMethodCall(e);
+        break;
+      case 101:
+        this._onSubscribe(e);
+        break;
+      case 102:
+        this._onUnsubscribe(e);
+        break;
+    }
+  }
+  _onMethodCall(e) {
+    const n = this._channels.get(e.channelName);
+    let s;
+    try {
+      if (!n)
+        throw new Error("[ChannelServer]: Channel not found!");
+      s = n.call(e.method, e.args);
+    } catch (i) {
+      s = Promise.reject(i);
+    }
+    s.then((i) => {
+      this._sendResponse({ seq: e.seq, type: 100, data: i });
+    }).catch((i) => {
+      i instanceof Error ? this._sendResponse({ seq: e.seq, type: 101, data: i.message }) : this._sendResponse({ seq: e.seq, type: 101, data: String(i) });
+    });
+  }
+  _onSubscribe(e) {
+    const n = this._channels.get(e.channelName);
+    try {
+      if (!n)
+        throw new Error("[ChannelServer]: Channel not found!");
+      const i = n.subscribe(e.method, e.args).subscribe({
+        next: (o) => {
+          this._sendResponse({ seq: e.seq, type: 200, data: o });
+        },
+        error: (o) => {
+          this._sendResponse({ seq: e.seq, type: 201, data: o.message }), this._sendResponse({
+            seq: e.seq,
+            type: 202
+            /* SUBSCRIBE_COMPLETE */
+          });
+        },
+        complete: () => {
+          this._sendResponse({
+            seq: e.seq,
+            type: 202
+            /* SUBSCRIBE_COMPLETE */
+          });
+        }
+      });
+      this._subscriptions.set(e.seq, i);
+    } catch (s) {
+      s instanceof Error ? this._sendResponse({ seq: e.seq, type: 201, data: s.message }) : this._sendResponse({ seq: e.seq, type: 201, data: String(s) });
+    }
+  }
+  _onUnsubscribe(e) {
+    const n = this._subscriptions.get(e.seq);
+    n && (n.unsubscribe(), this._subscriptions.delete(e.seq));
+  }
+  _sendResponse(e) {
+    this._protocol.send(e);
+  }
+}
+const U = B("IRPChannelService");
+class Re {
+  constructor(r) {
+    d(this, "_client");
+    d(this, "_server");
+    this._client = new mt(r), this._server = new _t(r);
+  }
+  requestChannel(r) {
+    return this._client.getChannel(r);
+  }
+  registerChannel(r, e) {
+    this._server.registerChannel(r, e);
+  }
+}
+var St = Object.defineProperty, wt = Object.getOwnPropertyDescriptor, gt = (t, r, e, n) => {
+  for (var s = n > 1 ? void 0 : n ? wt(r, e) : r, i = t.length - 1, o; i >= 0; i--)
+    (o = t[i]) && (s = (n ? o(r, e, s) : o(s)) || s);
+  return n && s && St(r, e, s), s;
+}, S = (t, r) => (e, n) => r(e, n, t);
+let w = class extends z {
+  constructor(r, e, n, s, i, o) {
+    super();
+    d(this, "_remoteInstanceService");
+    this._unsyncMutations = r, this._injector = e, this._commandService = n, this._univerInstanceService = s, this._rpcChannelService = i, this._remoteSyncService = o, this._initRPCChannels(), this._init();
+  }
+  _initRPCChannels() {
+    this._rpcChannelService.registerChannel(te, ge(this._remoteSyncService)), this._injector.add([
+      T,
+      {
+        useFactory: () => Pe(this._rpcChannelService.requestChannel(re))
+      }
+    ]), this._remoteInstanceService = this._injector.get(T);
+  }
+  _init() {
+    this._univerInstanceService.sheetAdded$.pipe(x(this.dispose$)).subscribe((r) => {
+      this._remoteInstanceService.createInstance({
+        unitID: r.getUnitId(),
+        type: ae.SHEET,
+        snapshot: r.getSnapshot()
+      });
+    }), this._univerInstanceService.sheetDisposed$.pipe(x(this.dispose$)).subscribe((r) => {
+      this._remoteInstanceService.disposeInstance({
+        unitID: r.getUnitId()
+      });
+    }), this.disposeWithMe(
+      // Mutations executed on the main thread should be synced to the worker thread.
+      this._commandService.onCommandExecuted((r, e) => {
+        r.type === he.MUTATION && !(e != null && e.fromSync) && !this._unsyncMutations.has(r.id) && this._remoteInstanceService.syncMutation({
+          mutationInfo: r
+        });
+      })
+    );
+  }
+};
+w = gt([
+  le(fe.Starting, w),
+  S(1, q(A)),
+  S(2, M),
+  S(3, ue),
+  S(4, U),
+  S(5, O)
+], w);
+var Pt = Object.defineProperty, Rt = Object.getOwnPropertyDescriptor, It = (t, r, e, n) => {
+  for (var s = n > 1 ? void 0 : n ? Rt(r, e) : r, i = t.length - 1, o; i >= 0; i--)
+    (o = t[i]) && (s = (n ? o(r, e, s) : o(s)) || s);
+  return n && s && Pt(r, e, s), s;
+}, I = (t, r) => (e, n) => r(e, n, t);
+let g = class extends Oe {
+  constructor(r, e, n, s) {
+    super();
+    d(this, "_remoteSyncService");
+    this._injector = r, this._remoteInstanceService = e, this._commandService = n, this._rpcChannelService = s, this._initRPCChannels(), this._init();
+  }
+  _initRPCChannels() {
+    this._rpcChannelService.registerChannel(re, ge(this._remoteInstanceService)), this._injector.add([
+      O,
+      {
+        useFactory: () => Pe(this._rpcChannelService.requestChannel(te))
+      }
+    ]), this._remoteSyncService = this._injector.get(O);
+  }
+  _init() {
+    this.disposeWithMe(
+      // Mutations executed on the main thread should be synced to the worker thread.
+      this._commandService.onCommandExecuted((r, e) => {
+        r.type === he.MUTATION && !(e != null && e.fromSync) && this._remoteSyncService.syncMutation({
+          mutationInfo: r
+        });
+      })
+    );
+  }
+};
+g = It([
+  le(fe.Starting, g),
+  I(0, q(A)),
+  I(1, T),
+  I(2, M),
+  I(3, U)
+], g);
+function Ct() {
+  return {
+    send(t) {
+      postMessage(t);
+    },
+    onMessage: new J((t) => {
+      const r = (e) => {
+        t.next(e.data);
+      };
+      return addEventListener("message", r), () => removeEventListener("message", r);
+    }).pipe(ye(1))
+  };
+}
+function Et(t) {
+  return {
+    send(r) {
+      t.postMessage(r);
+    },
+    onMessage: new J((r) => {
+      const e = (n) => {
+        r.next(n.data);
+      };
+      return t.addEventListener("message", e), () => t.removeEventListener("message", e);
+    }).pipe(ye(1))
+  };
+}
+var xt = Object.defineProperty, Ot = Object.getOwnPropertyDescriptor, Ie = (t, r, e, n) => {
+  for (var s = n > 1 ? void 0 : n ? Ot(r, e) : r, i = t.length - 1, o; i >= 0; i--)
+    (o = t[i]) && (s = (n ? o(r, e, s) : o(s)) || s);
+  return n && s && xt(r, e, s), s;
+}, Ce = (t, r) => (e, n) => r(e, n, t), D;
+let oe = (D = class extends pe {
+  constructor(t, r) {
+    super("UNIVER_RPC_MAIN_THREAD_PLUGIN"), this._config = t, this._injector = r;
+  }
+  async onStarting(t) {
+    const r = new Worker(this._config.workerURL), e = Et(r);
+    [
+      [
+        U,
+        {
+          useFactory: () => new Re(e)
+        }
+      ],
+      [
+        w,
+        {
+          useFactory: () => {
+            var s;
+            return t.createInstance(w, ((s = this._config) == null ? void 0 : s.unsyncMutations) ?? /* @__PURE__ */ new Set());
+          }
+        }
+      ],
+      [O, { useClass: Y }]
+    ].forEach((s) => t.add(s));
+  }
+}, d(D, "type", de.Univer), D);
+oe = Ie([
+  Ce(1, q(A))
+], oe);
+var L;
+let ce = (L = class extends pe {
+  constructor(t, r) {
+    super("UNIVER_RPC_WORKER_THREAD_PLUGIN"), this._config = t, this._injector = r;
+  }
+  onStarting(t) {
+    [
+      [g],
+      [
+        U,
+        {
+          useFactory: () => new Re(Ct())
+        }
+      ],
+      [T, { useClass: V }]
+    ].forEach((r) => t.add(r)), t.get(g);
+  }
+}, d(L, "type", de.Univer), L);
+ce = Ie([
+  Ce(1, q(A))
+], ce);
+export {
+  mt as ChannelClient,
+  _t as ChannelServer,
+  U as IRPChannelService,
+  oe as UniverRPCMainThreadPlugin,
+  ce as UniverRPCWorkerThreadPlugin
+};