@univerjs/drawing 0.5.0 → 0.5.1

package/lib/es/index.js

@@ -1,318 +1,329 @@
-var Ut = Object.defineProperty;
-var Mt = (n, e, t) => e in n ? Ut(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
-var V = (n, e, t) => Mt(n, typeof e != "symbol" ? e + "" : e, t);
-import { sortRules as Nt, sortRulesByDesc as Rt, createIdentifier as Ct, Tools as kt, Inject as St, Injector as jt, Plugin as Tt, mergeOverrideWithDependencies as $t, IConfigService as Wt } from "@univerjs/core";
-import { Subject as we } from "rxjs";
-const an = 500, cn = 500, un = 10, Gt = 5 * 1024 * 1024, Bt = ["image/png", "image/jpeg", "image/jpg", "image/gif", "image/bmp"];
-var Ce = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, F = {}, Et = {}, ct = {};
-Object.defineProperty(ct, "__esModule", { value: !0 });
-function xt(n, e) {
-  if (Array.isArray(e))
-    return !1;
-  for (let t in n)
-    if (!ut(n[t], e[t]))
+var jt = Object.defineProperty;
+var $t = (a, e, n) => e in a ? jt(a, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : a[e] = n;
+var F = (a, e, n) => $t(a, typeof e != "symbol" ? e + "" : e, n);
+import { sortRules as Nt, sortRulesByDesc as Rt, createIdentifier as xt, ImageSourceType as at, ImageUploadStatusType as et, Tools as Bt, Inject as Wt, Injector as Gt, Plugin as Lt, mergeOverrideWithDependencies as qt, IConfigService as Kt, IImageIoService as Ft } from "@univerjs/core";
+import { IImageIoService as wn, ImageSourceType as bn, ImageUploadStatusType as Cn } from "@univerjs/core";
+import { Subject as be } from "rxjs";
+const pn = 500, gn = 500, yn = 10, Vt = 5 * 1024 * 1024, Ht = ["image/png", "image/jpeg", "image/jpg", "image/gif", "image/bmp"];
+var Ve = {}, Ze = {}, tt = {}, _t;
+function zt() {
+  if (_t) return tt;
+  _t = 1, Object.defineProperty(tt, "__esModule", { value: !0 });
+  function a(t, r) {
+    if (Array.isArray(r))
       return !1;
-  for (let t in e)
-    if (n[t] === void 0)
-      return !1;
-  return !0;
-}
-function Lt(n, e) {
-  if (!Array.isArray(e) || n.length !== e.length)
-    return !1;
-  for (let t = 0; t < n.length; t++)
-    if (!ut(n[t], e[t]))
+    for (let u in t)
+      if (!n(t[u], r[u]))
+        return !1;
+    for (let u in r)
+      if (t[u] === void 0)
+        return !1;
+    return !0;
+  }
+  function e(t, r) {
+    if (!Array.isArray(r) || t.length !== r.length)
       return !1;
-  return !0;
-}
-function ut(n, e) {
-  return n === e ? !0 : n === null || e === null || typeof n != "object" || typeof e != "object" ? !1 : Array.isArray(n) ? Lt(n, e) : xt(n, e);
-}
-ct.default = ut;
-var dt = {};
-Object.defineProperty(dt, "__esModule", { value: !0 });
-function lt(n) {
-  if (n === null)
-    return null;
-  if (Array.isArray(n))
-    return n.map(lt);
-  if (typeof n == "object") {
-    const e = {};
-    for (let t in n)
-      e[t] = lt(n[t]);
-    return e;
-  } else
-    return n;
-}
-dt.default = lt;
-var ft = {};
-(function(n) {
-  Object.defineProperty(n, "__esModule", { value: !0 }), n.eachChildOf = n.advancer = n.readCursor = n.writeCursor = n.WriteCursor = n.ReadCursor = n.isValidPathItem = void 0;
-  function e(O, o) {
-    if (!O)
-      throw new Error(o);
-  }
-  const t = (O) => O != null && typeof O == "object" && !Array.isArray(O), i = (O, o) => (
-    // All the numbers, then all the letters. Just as the gods of ascii intended.
-    typeof O == typeof o ? O > o : typeof O == "string" && typeof o == "number"
-  );
-  function s(O, o) {
-    for (let c in O) {
-      const h = c;
-      o.write(h, O[h]);
-    }
+    for (let u = 0; u < t.length; u++)
+      if (!n(t[u], r[u]))
+        return !1;
+    return !0;
   }
-  n.isValidPathItem = (O) => typeof O == "number" || typeof O == "string" && O !== "__proto__";
-  class d {
-    constructor(o = null) {
-      this.parents = [], this.indexes = [], this.lcIdx = -1, this.idx = -1, this.container = o;
-    }
-    ascend() {
-      e(this.parents.length === this.indexes.length / 2), this.idx === 0 ? this.parents.length ? (this.lcIdx = this.indexes.pop(), this.container = this.parents.pop(), this.idx = this.indexes.pop()) : (this.lcIdx = 0, this.idx = -1) : (e(this.idx > 0), this.idx--, t(this.container[this.idx]) && this.idx--);
-    }
-    getPath() {
-      const o = [];
-      let c = this.container, h = this.parents.length - 1, k = this.idx;
-      for (; k >= 0; )
-        o.unshift(c[k]), k === 0 ? (k = this.indexes[h * 2], c = this.parents[h--]) : k -= t(c[k - 1]) ? 2 : 1;
-      return o;
-    }
+  function n(t, r) {
+    return t === r ? !0 : t === null || r === null || typeof t != "object" || typeof r != "object" ? !1 : Array.isArray(t) ? e(t, r) : a(t, r);
   }
-  class l extends d {
-    get() {
-      return this.container ? this.container.slice(this.idx + 1) : null;
-    }
-    // Its only valid to call this after descending into a child.
-    getKey() {
-      return e(this.container != null, "Invalid call to getKey before cursor descended"), this.container[this.idx];
-    }
-    getComponent() {
-      let o;
-      return this.container && this.container.length > this.idx + 1 && t(o = this.container[this.idx + 1]) ? o : null;
-    }
-    descendFirst() {
-      let o = this.idx + 1;
-      if (!this.container || o >= this.container.length || t(this.container[o]) && o + 1 >= this.container.length)
-        return !1;
-      t(this.container[o]) && o++;
-      const c = this.container[o];
-      return Array.isArray(c) ? (this.indexes.push(this.idx), this.parents.push(this.container), this.indexes.push(o), this.idx = 0, this.container = c) : this.idx = o, !0;
-    }
-    nextSibling() {
-      if (e(this.parents.length === this.indexes.length / 2), this.idx > 0 || this.parents.length === 0)
-        return !1;
-      const o = this.indexes[this.indexes.length - 1] + 1, c = this.parents[this.parents.length - 1];
-      return o >= c.length ? !1 : (e(!isNaN(o)), this.indexes[this.indexes.length - 1] = o, this.container = c[o], !0);
-    }
-    _init(o, c, h, k) {
-      this.container = o, this.idx = c, this.parents = h.slice(), this.indexes = k.slice();
-    }
-    clone() {
-      const o = new l();
-      return o._init(this.container, this.idx, this.parents, this.indexes), o;
+  return tt.default = n, tt;
+}
+var nt = {}, vt;
+function Xt() {
+  if (vt) return nt;
+  vt = 1, Object.defineProperty(nt, "__esModule", { value: !0 });
+  function a(e) {
+    if (e === null)
+      return null;
+    if (Array.isArray(e))
+      return e.map(a);
+    if (typeof e == "object") {
+      const n = {};
+      for (let t in e)
+        n[t] = a(e[t]);
+      return n;
+    } else
+      return e;
+  }
+  return nt.default = a, nt;
+}
+var lt = {}, mt;
+function At() {
+  return mt || (mt = 1, function(a) {
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.eachChildOf = a.advancer = a.readCursor = a.writeCursor = a.WriteCursor = a.ReadCursor = a.isValidPathItem = void 0;
+    function e(_, s) {
+      if (!_)
+        throw new Error(s);
     }
-    *[Symbol.iterator]() {
-      if (this.descendFirst()) {
-        do
-          yield this.getKey();
-        while (this.nextSibling());
-        this.ascend();
+    const n = (_) => _ != null && typeof _ == "object" && !Array.isArray(_), t = (_, s) => (
+      // All the numbers, then all the letters. Just as the gods of ascii intended.
+      typeof _ == typeof s ? _ > s : typeof _ == "string" && typeof s == "number"
+    );
+    function r(_, s) {
+      for (let c in _) {
+        const h = c;
+        s.write(h, _[h]);
       }
     }
-    // TODO(cleanup): Consider moving these functions out of cursor, since
-    // they're really just helper methods.
-    // It'd be really nice to do this using generators.
-    traverse(o, c) {
-      const h = this.getComponent();
-      h && c(h, o);
-      for (const k of this)
-        o && o.descend(k), this.traverse(o, c), o && o.ascend();
-    }
-    eachPick(o, c) {
-      this.traverse(o, (h, k) => {
-        h.p != null && c(h.p, k);
-      });
-    }
-    eachDrop(o, c) {
-      this.traverse(o, (h, k) => {
-        h.d != null && c(h.d, k);
-      });
+    a.isValidPathItem = (_) => typeof _ == "number" || typeof _ == "string" && _ !== "__proto__";
+    class u {
+      constructor(s = null) {
+        this.parents = [], this.indexes = [], this.lcIdx = -1, this.idx = -1, this.container = s;
+      }
+      ascend() {
+        e(this.parents.length === this.indexes.length / 2), this.idx === 0 ? this.parents.length ? (this.lcIdx = this.indexes.pop(), this.container = this.parents.pop(), this.idx = this.indexes.pop()) : (this.lcIdx = 0, this.idx = -1) : (e(this.idx > 0), this.idx--, n(this.container[this.idx]) && this.idx--);
+      }
+      getPath() {
+        const s = [];
+        let c = this.container, h = this.parents.length - 1, S = this.idx;
+        for (; S >= 0; )
+          s.unshift(c[S]), S === 0 ? (S = this.indexes[h * 2], c = this.parents[h--]) : S -= n(c[S - 1]) ? 2 : 1;
+        return s;
+      }
     }
-  }
-  n.ReadCursor = l;
-  class a extends d {
-    constructor(o = null) {
-      super(o), this.pendingDescent = [], this._op = o;
+    class o extends u {
+      get() {
+        return this.container ? this.container.slice(this.idx + 1) : null;
+      }
+      // Its only valid to call this after descending into a child.
+      getKey() {
+        return e(this.container != null, "Invalid call to getKey before cursor descended"), this.container[this.idx];
+      }
+      getComponent() {
+        let s;
+        return this.container && this.container.length > this.idx + 1 && n(s = this.container[this.idx + 1]) ? s : null;
+      }
+      descendFirst() {
+        let s = this.idx + 1;
+        if (!this.container || s >= this.container.length || n(this.container[s]) && s + 1 >= this.container.length)
+          return !1;
+        n(this.container[s]) && s++;
+        const c = this.container[s];
+        return Array.isArray(c) ? (this.indexes.push(this.idx), this.parents.push(this.container), this.indexes.push(s), this.idx = 0, this.container = c) : this.idx = s, !0;
+      }
+      nextSibling() {
+        if (e(this.parents.length === this.indexes.length / 2), this.idx > 0 || this.parents.length === 0)
+          return !1;
+        const s = this.indexes[this.indexes.length - 1] + 1, c = this.parents[this.parents.length - 1];
+        return s >= c.length ? !1 : (e(!isNaN(s)), this.indexes[this.indexes.length - 1] = s, this.container = c[s], !0);
+      }
+      _init(s, c, h, S) {
+        this.container = s, this.idx = c, this.parents = h.slice(), this.indexes = S.slice();
+      }
+      clone() {
+        const s = new o();
+        return s._init(this.container, this.idx, this.parents, this.indexes), s;
+      }
+      *[Symbol.iterator]() {
+        if (this.descendFirst()) {
+          do
+            yield this.getKey();
+          while (this.nextSibling());
+          this.ascend();
+        }
+      }
+      // TODO(cleanup): Consider moving these functions out of cursor, since
+      // they're really just helper methods.
+      // It'd be really nice to do this using generators.
+      traverse(s, c) {
+        const h = this.getComponent();
+        h && c(h, s);
+        for (const S of this)
+          s && s.descend(S), this.traverse(s, c), s && s.ascend();
+      }
+      eachPick(s, c) {
+        this.traverse(s, (h, S) => {
+          h.p != null && c(h.p, S);
+        });
+      }
+      eachDrop(s, c) {
+        this.traverse(s, (h, S) => {
+          h.d != null && c(h.d, S);
+        });
+      }
     }
-    flushDescent() {
-      e(this.parents.length === this.indexes.length / 2), this.container === null && (this._op = this.container = []);
-      for (let o = 0; o < this.pendingDescent.length; o++) {
-        const c = this.pendingDescent[o];
-        let h = this.idx + 1;
-        if (h < this.container.length && t(this.container[h]) && h++, e(h === this.container.length || !t(this.container[h])), h === this.container.length)
-          this.container.push(c), this.idx = h;
-        else if (this.container[h] === c)
-          this.idx = h;
-        else {
-          if (!Array.isArray(this.container[h])) {
-            const k = this.container.splice(h, this.container.length - h);
-            this.container.push(k), this.lcIdx > -1 && (this.lcIdx = h);
-          }
-          for (this.indexes.push(this.idx), this.parents.push(this.container), this.lcIdx !== -1 && (e(i(c, this.container[this.lcIdx][0])), h = this.lcIdx + 1, this.lcIdx = -1); h < this.container.length && i(c, this.container[h][0]); )
-            h++;
-          if (this.indexes.push(h), this.idx = 0, h < this.container.length && this.container[h][0] === c)
-            this.container = this.container[h];
+    a.ReadCursor = o;
+    class l extends u {
+      constructor(s = null) {
+        super(s), this.pendingDescent = [], this._op = s;
+      }
+      flushDescent() {
+        e(this.parents.length === this.indexes.length / 2), this.container === null && (this._op = this.container = []);
+        for (let s = 0; s < this.pendingDescent.length; s++) {
+          const c = this.pendingDescent[s];
+          let h = this.idx + 1;
+          if (h < this.container.length && n(this.container[h]) && h++, e(h === this.container.length || !n(this.container[h])), h === this.container.length)
+            this.container.push(c), this.idx = h;
+          else if (this.container[h] === c)
+            this.idx = h;
           else {
-            const k = [c];
-            this.container.splice(h, 0, k), this.container = k;
+            if (!Array.isArray(this.container[h])) {
+              const S = this.container.splice(h, this.container.length - h);
+              this.container.push(S), this.lcIdx > -1 && (this.lcIdx = h);
+            }
+            for (this.indexes.push(this.idx), this.parents.push(this.container), this.lcIdx !== -1 && (e(t(c, this.container[this.lcIdx][0])), h = this.lcIdx + 1, this.lcIdx = -1); h < this.container.length && t(c, this.container[h][0]); )
+              h++;
+            if (this.indexes.push(h), this.idx = 0, h < this.container.length && this.container[h][0] === c)
+              this.container = this.container[h];
+            else {
+              const S = [c];
+              this.container.splice(h, 0, S), this.container = S;
+            }
           }
         }
+        this.pendingDescent.length = 0;
       }
-      this.pendingDescent.length = 0;
-    }
-    reset() {
-      this.lcIdx = -1;
-    }
-    // Creates and returns a component, creating one if need be. You should
-    // probably write to it immediately - ops are not valid with empty
-    // components.
-    getComponent() {
-      this.flushDescent();
-      const o = this.idx + 1;
-      if (o < this.container.length && t(this.container[o]))
-        return this.container[o];
-      {
-        const c = {};
-        return this.container.splice(o, 0, c), c;
+      reset() {
+        this.lcIdx = -1;
       }
-    }
-    write(o, c) {
-      const h = this.getComponent();
-      e(h[o] == null || h[o] === c, "Internal consistency error: Overwritten component. File a bug"), h[o] = c;
-    }
-    get() {
-      return this._op;
-    }
-    descend(o) {
-      if (!n.isValidPathItem(o))
-        throw Error("Invalid JSON key");
-      this.pendingDescent.push(o);
-    }
-    descendPath(o) {
-      return this.pendingDescent.push(...o), this;
-    }
-    ascend() {
-      this.pendingDescent.length ? this.pendingDescent.pop() : super.ascend();
-    }
-    mergeTree(o, c = s) {
-      if (o === null)
-        return;
-      if (e(Array.isArray(o)), o === this._op)
-        throw Error("Cannot merge into my own tree");
-      const h = this.lcIdx, k = this.parents.length;
-      let Z = 0;
-      for (let pe = 0; pe < o.length; pe++) {
-        const J = o[pe];
-        typeof J == "string" || typeof J == "number" ? (Z++, this.descend(J)) : Array.isArray(J) ? this.mergeTree(J, c) : typeof J == "object" && c(J, this);
+      // Creates and returns a component, creating one if need be. You should
+      // probably write to it immediately - ops are not valid with empty
+      // components.
+      getComponent() {
+        this.flushDescent();
+        const s = this.idx + 1;
+        if (s < this.container.length && n(this.container[s]))
+          return this.container[s];
+        {
+          const c = {};
+          return this.container.splice(s, 0, c), c;
+        }
+      }
+      write(s, c) {
+        const h = this.getComponent();
+        e(h[s] == null || h[s] === c, "Internal consistency error: Overwritten component. File a bug"), h[s] = c;
+      }
+      get() {
+        return this._op;
+      }
+      descend(s) {
+        if (!a.isValidPathItem(s))
+          throw Error("Invalid JSON key");
+        this.pendingDescent.push(s);
+      }
+      descendPath(s) {
+        return this.pendingDescent.push(...s), this;
+      }
+      ascend() {
+        this.pendingDescent.length ? this.pendingDescent.pop() : super.ascend();
+      }
+      mergeTree(s, c = r) {
+        if (s === null)
+          return;
+        if (e(Array.isArray(s)), s === this._op)
+          throw Error("Cannot merge into my own tree");
+        const h = this.lcIdx, S = this.parents.length;
+        let Y = 0;
+        for (let pe = 0; pe < s.length; pe++) {
+          const Z = s[pe];
+          typeof Z == "string" || typeof Z == "number" ? (Y++, this.descend(Z)) : Array.isArray(Z) ? this.mergeTree(Z, c) : typeof Z == "object" && c(Z, this);
+        }
+        for (; Y--; )
+          this.ascend();
+        this.lcIdx = this.parents.length === S ? h : -1;
+      }
+      at(s, c) {
+        this.descendPath(s), c(this);
+        for (let h = 0; h < s.length; h++)
+          this.ascend();
+        return this;
+      }
+      // This is used by helpers, so the strict ordering guarantees are
+      // relaxed.
+      writeAtPath(s, c, h) {
+        return this.at(s, () => this.write(c, h)), this.reset(), this;
+      }
+      writeMove(s, c, h = 0) {
+        return this.writeAtPath(s, "p", h).writeAtPath(c, "d", h);
+      }
+      getPath() {
+        const s = super.getPath();
+        return s.push(...this.pendingDescent), s;
       }
-      for (; Z--; )
-        this.ascend();
-      this.lcIdx = this.parents.length === k ? h : -1;
-    }
-    at(o, c) {
-      this.descendPath(o), c(this);
-      for (let h = 0; h < o.length; h++)
-        this.ascend();
-      return this;
-    }
-    // This is used by helpers, so the strict ordering guarantees are
-    // relaxed.
-    writeAtPath(o, c, h) {
-      return this.at(o, () => this.write(c, h)), this.reset(), this;
-    }
-    writeMove(o, c, h = 0) {
-      return this.writeAtPath(o, "p", h).writeAtPath(c, "d", h);
-    }
-    getPath() {
-      const o = super.getPath();
-      return o.push(...this.pendingDescent), o;
     }
-  }
-  n.WriteCursor = a, n.writeCursor = () => new a(), n.readCursor = (O) => new l(O);
-  function E(O, o, c) {
-    let h, k;
-    k = h = O ? O.descendFirst() : !1;
-    function Z(pe) {
-      let J;
-      for (; k; ) {
-        const Ie = J = O.getKey();
-        if (pe != null) {
-          let xe = !1;
-          if (o && typeof Ie == "number" && (J = o(Ie, O.getComponent()), J < 0 && (J = ~J, xe = !0)), i(J, pe))
-            return null;
-          if (J === pe && !xe)
-            return O;
+    a.WriteCursor = l, a.writeCursor = () => new l(), a.readCursor = (_) => new o(_);
+    function E(_, s, c) {
+      let h, S;
+      S = h = _ ? _.descendFirst() : !1;
+      function Y(pe) {
+        let Z;
+        for (; S; ) {
+          const Ce = Z = _.getKey();
+          if (pe != null) {
+            let Ge = !1;
+            if (s && typeof Ce == "number" && (Z = s(Ce, _.getComponent()), Z < 0 && (Z = ~Z, Ge = !0)), t(Z, pe))
+              return null;
+            if (Z === pe && !Ge)
+              return _;
+          }
+          c && typeof Z == "number" && c(Z, _.getComponent()), S = _.nextSibling();
         }
-        c && typeof J == "number" && c(J, O.getComponent()), k = O.nextSibling();
+        return null;
       }
-      return null;
+      return Y.end = () => {
+        h && _.ascend();
+      }, Y;
     }
-    return Z.end = () => {
-      h && O.ascend();
-    }, Z;
-  }
-  n.advancer = E;
-  function W(O, o, c) {
-    let h, k, Z, pe;
-    for (h = k = O && O.descendFirst(), Z = pe = o && o.descendFirst(); h || Z; ) {
-      let J = h ? O.getKey() : null, Ie = Z ? o.getKey() : null;
-      J !== null && Ie !== null && (i(Ie, J) ? Ie = null : J !== Ie && (J = null)), c(J == null ? Ie : J, J != null ? O : null, Ie != null ? o : null), J != null && h && (h = O.nextSibling()), Ie != null && Z && (Z = o.nextSibling());
+    a.advancer = E;
+    function x(_, s, c) {
+      let h, S, Y, pe;
+      for (h = S = _ && _.descendFirst(), Y = pe = s && s.descendFirst(); h || Y; ) {
+        let Z = h ? _.getKey() : null, Ce = Y ? s.getKey() : null;
+        Z !== null && Ce !== null && (t(Ce, Z) ? Ce = null : Z !== Ce && (Z = null)), c(Z == null ? Ce : Z, Z != null ? _ : null, Ce != null ? s : null), Z != null && h && (h = _.nextSibling()), Ce != null && Y && (Y = s.nextSibling());
+      }
+      S && _.ascend(), pe && s.ascend();
     }
-    k && O.ascend(), pe && o.ascend();
-  }
-  n.eachChildOf = W;
-})(ft);
-var ht = {};
-(function(n) {
-  Object.defineProperty(n, "__esModule", { value: !0 }), n.ConflictType = void 0, function(e) {
-    e[e.RM_UNEXPECTED_CONTENT = 1] = "RM_UNEXPECTED_CONTENT", e[e.DROP_COLLISION = 2] = "DROP_COLLISION", e[e.BLACKHOLE = 3] = "BLACKHOLE";
-  }(n.ConflictType || (n.ConflictType = {}));
-})(ht);
-var it = {}, Fe = {}, vt;
-function pt() {
-  return vt || (vt = 1, Object.defineProperty(Fe, "__esModule", { value: !0 }), Fe.uniToStrPos = Fe.strPosToUni = void 0, Fe.strPosToUni = (n, e = n.length) => {
-    let t = 0, i = 0;
-    for (; i < e; i++) {
-      const s = n.charCodeAt(i);
-      s >= 55296 && s <= 57343 && (t++, i++);
+    a.eachChildOf = x;
+  }(lt)), lt;
+}
+var ut = {}, Ot;
+function Mt() {
+  return Ot || (Ot = 1, function(a) {
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.ConflictType = void 0, function(e) {
+      e[e.RM_UNEXPECTED_CONTENT = 1] = "RM_UNEXPECTED_CONTENT", e[e.DROP_COLLISION = 2] = "DROP_COLLISION", e[e.BLACKHOLE = 3] = "BLACKHOLE";
+    }(a.ConflictType || (a.ConflictType = {}));
+  }(ut)), ut;
+}
+var Se = {}, He = {}, wt;
+function ht() {
+  return wt || (wt = 1, Object.defineProperty(He, "__esModule", { value: !0 }), He.uniToStrPos = He.strPosToUni = void 0, He.strPosToUni = (a, e = a.length) => {
+    let n = 0, t = 0;
+    for (; t < e; t++) {
+      const r = a.charCodeAt(t);
+      r >= 55296 && r <= 57343 && (n++, t++);
     }
-    if (i !== e)
+    if (t !== e)
       throw Error("Invalid offset - splits unicode bytes");
-    return i - t;
-  }, Fe.uniToStrPos = (n, e) => {
-    let t = 0;
+    return t - n;
+  }, He.uniToStrPos = (a, e) => {
+    let n = 0;
     for (; e > 0; e--) {
-      const i = n.charCodeAt(t);
-      t += i >= 55296 && i <= 57343 ? 2 : 1;
+      const t = a.charCodeAt(n);
+      n += t >= 55296 && t <= 57343 ? 2 : 1;
     }
-    return t;
-  }), Fe;
+    return n;
+  }), He;
 }
-var st = {}, yt;
-function at() {
-  return yt || (yt = 1, function(n) {
-    Object.defineProperty(n, "__esModule", { value: !0 }), n.uniSlice = n.dlen = n.eachOp = void 0;
-    const e = pt(), t = (f) => {
+var ct = {}, bt;
+function ft() {
+  return bt || (bt = 1, function(a) {
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.uniSlice = a.dlen = a.eachOp = void 0;
+    const e = ht(), n = (f) => {
       if (!Array.isArray(f))
         throw Error("Op must be an array of components");
-      let _ = null;
-      for (let w = 0; w < f.length; w++) {
-        const L = f[w];
+      let y = null;
+      for (let b = 0; b < f.length; b++) {
+        const L = f[b];
         switch (typeof L) {
           case "object":
             if (typeof L.d != "number" && typeof L.d != "string")
               throw Error("Delete must be number or string");
-            if (n.dlen(L.d) <= 0)
+            if (a.dlen(L.d) <= 0)
               throw Error("Deletes must not be empty");
             break;
           case "string":
@@ -322,234 +333,236 @@ function at() {
           case "number":
             if (!(L > 0))
               throw Error("Skip components must be >0");
-            if (typeof _ == "number")
+            if (typeof y == "number")
               throw Error("Adjacent skip components should be combined");
             break;
         }
-        _ = L;
+        y = L;
       }
-      if (typeof _ == "number")
+      if (typeof y == "number")
         throw Error("Op has a trailing skip");
     };
-    function i(f, _) {
-      let w = 0, L = 0;
+    function t(f, y) {
+      let b = 0, L = 0;
       for (let z = 0; z < f.length; z++) {
-        const H = f[z];
-        switch (_(H, w, L), typeof H) {
+        const q = f[z];
+        switch (y(q, b, L), typeof q) {
           case "object":
-            w += n.dlen(H.d);
+            b += a.dlen(q.d);
             break;
           case "string":
-            L += e.strPosToUni(H);
+            L += e.strPosToUni(q);
             break;
           case "number":
-            w += H, L += H;
+            b += q, L += q;
             break;
         }
       }
     }
-    n.eachOp = i;
-    function s(f, _) {
-      const w = [], L = a(w);
-      return i(f, (z, H, De) => {
-        L(_(z, H, De));
-      }), o(w);
+    a.eachOp = t;
+    function r(f, y) {
+      const b = [], L = l(b);
+      return t(f, (z, q, Ee) => {
+        L(y(z, q, Ee));
+      }), s(b);
     }
-    const d = (f) => f, l = (f) => s(f, d);
-    n.dlen = (f) => typeof f == "number" ? f : e.strPosToUni(f);
-    const a = (f) => (_) => {
-      if (!(!_ || _.d === 0 || _.d === "")) if (f.length === 0)
-        f.push(_);
-      else if (typeof _ == typeof f[f.length - 1])
-        if (typeof _ == "object") {
-          const w = f[f.length - 1];
-          w.d = typeof w.d == "string" && typeof _.d == "string" ? w.d + _.d : n.dlen(w.d) + n.dlen(_.d);
+    const u = (f) => f, o = (f) => r(f, u);
+    a.dlen = (f) => typeof f == "number" ? f : e.strPosToUni(f);
+    const l = (f) => (y) => {
+      if (!(!y || y.d === 0 || y.d === "")) if (f.length === 0)
+        f.push(y);
+      else if (typeof y == typeof f[f.length - 1])
+        if (typeof y == "object") {
+          const b = f[f.length - 1];
+          b.d = typeof b.d == "string" && typeof y.d == "string" ? b.d + y.d : a.dlen(b.d) + a.dlen(y.d);
         } else
-          f[f.length - 1] += _;
+          f[f.length - 1] += y;
       else
-        f.push(_);
+        f.push(y);
     }, E = (f) => typeof f == "number" ? f : typeof f == "string" ? e.strPosToUni(f) : typeof f.d == "number" ? f.d : e.strPosToUni(f.d);
-    n.uniSlice = (f, _, w) => {
-      const L = e.uniToStrPos(f, _), z = w == null ? 1 / 0 : e.uniToStrPos(f, w);
+    a.uniSlice = (f, y, b) => {
+      const L = e.uniToStrPos(f, y), z = b == null ? 1 / 0 : e.uniToStrPos(f, b);
       return f.slice(L, z);
     };
-    const W = (f, _, w) => typeof f == "number" ? w == null ? f - _ : Math.min(f, w) - _ : n.uniSlice(f, _, w), O = (f) => {
-      let _ = 0, w = 0;
-      return { take: (H, De) => {
-        if (_ === f.length)
-          return H === -1 ? null : H;
-        const ue = f[_];
+    const x = (f, y, b) => typeof f == "number" ? b == null ? f - y : Math.min(f, b) - y : a.uniSlice(f, y, b), _ = (f) => {
+      let y = 0, b = 0;
+      return { take: (q, Ee) => {
+        if (y === f.length)
+          return q === -1 ? null : q;
+        const ce = f[y];
         let ne;
-        if (typeof ue == "number")
-          return H === -1 || ue - w <= H ? (ne = ue - w, ++_, w = 0, ne) : (w += H, H);
-        if (typeof ue == "string") {
-          if (H === -1 || De === "i" || e.strPosToUni(ue.slice(w)) <= H)
-            return ne = ue.slice(w), ++_, w = 0, ne;
+        if (typeof ce == "number")
+          return q === -1 || ce - b <= q ? (ne = ce - b, ++y, b = 0, ne) : (b += q, q);
+        if (typeof ce == "string") {
+          if (q === -1 || Ee === "i" || e.strPosToUni(ce.slice(b)) <= q)
+            return ne = ce.slice(b), ++y, b = 0, ne;
           {
-            const ae = w + e.uniToStrPos(ue.slice(w), H);
-            return ne = ue.slice(w, ae), w = ae, ne;
+            const le = b + e.uniToStrPos(ce.slice(b), q);
+            return ne = ce.slice(b, le), b = le, ne;
           }
         } else {
-          if (H === -1 || De === "d" || n.dlen(ue.d) - w <= H)
-            return ne = { d: W(ue.d, w) }, ++_, w = 0, ne;
+          if (q === -1 || Ee === "d" || a.dlen(ce.d) - b <= q)
+            return ne = { d: x(ce.d, b) }, ++y, b = 0, ne;
           {
-            let ae = W(ue.d, w, w + H);
-            return w += H, { d: ae };
+            let le = x(ce.d, b, b + q);
+            return b += q, { d: le };
           }
         }
-      }, peek: () => f[_] };
-    }, o = (f) => (f.length > 0 && typeof f[f.length - 1] == "number" && f.pop(), f);
-    function c(f, _, w) {
-      if (w !== "left" && w !== "right")
-        throw Error("side (" + w + ") must be 'left' or 'right'");
-      t(f), t(_);
-      const L = [], z = a(L), { take: H, peek: De } = O(f);
-      for (let ne = 0; ne < _.length; ne++) {
-        const ae = _[ne];
-        let ge, Ae;
-        switch (typeof ae) {
+      }, peek: () => f[y] };
+    }, s = (f) => (f.length > 0 && typeof f[f.length - 1] == "number" && f.pop(), f);
+    function c(f, y, b) {
+      if (b !== "left" && b !== "right")
+        throw Error("side (" + b + ") must be 'left' or 'right'");
+      n(f), n(y);
+      const L = [], z = l(L), { take: q, peek: Ee } = _(f);
+      for (let ne = 0; ne < y.length; ne++) {
+        const le = y[ne];
+        let ge, De;
+        switch (typeof le) {
           case "number":
-            for (ge = ae; ge > 0; )
-              Ae = H(ge, "i"), z(Ae), typeof Ae != "string" && (ge -= E(Ae));
+            for (ge = le; ge > 0; )
+              De = q(ge, "i"), z(De), typeof De != "string" && (ge -= E(De));
             break;
           case "string":
-            w === "left" && typeof De() == "string" && z(H(-1)), z(e.strPosToUni(ae));
+            b === "left" && typeof Ee() == "string" && z(q(-1)), z(e.strPosToUni(le));
             break;
           case "object":
-            for (ge = n.dlen(ae.d); ge > 0; )
-              switch (Ae = H(ge, "i"), typeof Ae) {
+            for (ge = a.dlen(le.d); ge > 0; )
+              switch (De = q(ge, "i"), typeof De) {
                 case "number":
-                  ge -= Ae;
+                  ge -= De;
                   break;
                 case "string":
-                  z(Ae);
+                  z(De);
                   break;
                 case "object":
-                  ge -= n.dlen(Ae.d);
+                  ge -= a.dlen(De.d);
               }
             break;
         }
       }
-      let ue;
-      for (; ue = H(-1); )
-        z(ue);
-      return o(L);
+      let ce;
+      for (; ce = q(-1); )
+        z(ce);
+      return s(L);
     }
-    function h(f, _) {
-      t(f), t(_);
-      const w = [], L = a(w), { take: z } = O(f);
-      for (let De = 0; De < _.length; De++) {
-        const ue = _[De];
-        let ne, ae;
-        switch (typeof ue) {
+    function h(f, y) {
+      n(f), n(y);
+      const b = [], L = l(b), { take: z } = _(f);
+      for (let Ee = 0; Ee < y.length; Ee++) {
+        const ce = y[Ee];
+        let ne, le;
+        switch (typeof ce) {
           case "number":
-            for (ne = ue; ne > 0; )
-              ae = z(ne, "d"), L(ae), typeof ae != "object" && (ne -= E(ae));
+            for (ne = ce; ne > 0; )
+              le = z(ne, "d"), L(le), typeof le != "object" && (ne -= E(le));
             break;
           case "string":
-            L(ue);
+            L(ce);
             break;
           case "object":
-            ne = n.dlen(ue.d);
+            ne = a.dlen(ce.d);
             let ge = 0;
             for (; ge < ne; )
-              switch (ae = z(ne - ge, "d"), typeof ae) {
+              switch (le = z(ne - ge, "d"), typeof le) {
                 case "number":
-                  L({ d: W(ue.d, ge, ge + ae) }), ge += ae;
+                  L({ d: x(ce.d, ge, ge + le) }), ge += le;
                   break;
                 case "string":
-                  ge += e.strPosToUni(ae);
+                  ge += e.strPosToUni(le);
                   break;
                 case "object":
-                  L(ae);
+                  L(le);
               }
             break;
         }
       }
-      let H;
-      for (; H = z(-1); )
-        L(H);
-      return o(w);
+      let q;
+      for (; q = z(-1); )
+        L(q);
+      return s(b);
     }
-    const k = (f, _) => {
-      let w = 0;
-      for (let L = 0; L < _.length && f > w; L++) {
-        const z = _[L];
+    const S = (f, y) => {
+      let b = 0;
+      for (let L = 0; L < y.length && f > b; L++) {
+        const z = y[L];
         switch (typeof z) {
           case "number": {
-            w += z;
+            b += z;
             break;
           }
           case "string":
-            const H = e.strPosToUni(z);
-            w += H, f += H;
+            const q = e.strPosToUni(z);
+            b += q, f += q;
             break;
           case "object":
-            f -= Math.min(n.dlen(z.d), f - w);
+            f -= Math.min(a.dlen(z.d), f - b);
             break;
         }
       }
       return f;
-    }, Z = (f, _) => typeof f == "number" ? k(f, _) : f.map((w) => k(w, _));
-    function pe(f, _, w) {
-      return s(f, (L, z) => typeof L == "object" && typeof L.d == "number" ? { d: w.slice(_, z, z + L.d) } : L);
+    }, Y = (f, y) => typeof f == "number" ? S(f, y) : f.map((b) => S(b, y));
+    function pe(f, y, b) {
+      return r(f, (L, z) => typeof L == "object" && typeof L.d == "number" ? { d: b.slice(y, z, z + L.d) } : L);
     }
-    function J(f) {
-      return s(f, (_) => {
-        switch (typeof _) {
+    function Z(f) {
+      return r(f, (y) => {
+        switch (typeof y) {
           case "object":
-            if (typeof _.d == "number")
+            if (typeof y.d == "number")
               throw Error("Cannot invert text op: Deleted characters missing from operation. makeInvertible must be called first.");
-            return _.d;
+            return y.d;
+          // delete -> insert
           case "string":
-            return { d: _ };
+            return { d: y };
+          // Insert -> delete
           case "number":
-            return _;
+            return y;
         }
       });
     }
-    function Ie(f) {
-      return s(f, (_) => typeof _ == "object" && typeof _.d == "string" ? { d: e.strPosToUni(_.d) } : _);
+    function Ce(f) {
+      return r(f, (y) => typeof y == "object" && typeof y.d == "string" ? { d: e.strPosToUni(y.d) } : y);
     }
-    function xe(f) {
-      let _ = !0;
-      return i(f, (w) => {
-        typeof w == "object" && typeof w.d == "number" && (_ = !1);
-      }), _;
+    function Ge(f) {
+      let y = !0;
+      return t(f, (b) => {
+        typeof b == "object" && typeof b.d == "number" && (y = !1);
+      }), y;
     }
     function ve(f) {
       return {
         name: "text-unicode",
         uri: "http://sharejs.org/types/text-unicode",
-        trim: o,
-        normalize: l,
-        checkOp: t,
+        trim: s,
+        normalize: o,
+        checkOp: n,
         /** Create a new text snapshot.
          *
          * @param {string} initial - initial snapshot data. Optional. Defaults to ''.
          * @returns {Snap} Initial document snapshot object
          */
-        create(_ = "") {
-          if (typeof _ != "string")
+        create(y = "") {
+          if (typeof y != "string")
             throw Error("Initial data must be a string");
-          return f.create(_);
+          return f.create(y);
         },
         /** Apply an operation to a document snapshot
          */
-        apply(_, w) {
-          t(w);
-          const L = f.builder(_);
-          for (let z = 0; z < w.length; z++) {
-            const H = w[z];
-            switch (typeof H) {
+        apply(y, b) {
+          n(b);
+          const L = f.builder(y);
+          for (let z = 0; z < b.length; z++) {
+            const q = b[z];
+            switch (typeof q) {
               case "number":
-                L.skip(H);
+                L.skip(q);
                 break;
               case "string":
-                L.append(H);
+                L.append(q);
                 break;
               case "object":
-                L.del(n.dlen(H.d));
+                L.del(a.dlen(q.d));
                 break;
             }
           }
@@ -557,58 +570,58 @@ function at() {
         },
         transform: c,
         compose: h,
-        transformPosition: k,
-        transformSelection: Z,
-        isInvertible: xe,
-        makeInvertible(_, w) {
-          return pe(_, w, f);
+        transformPosition: S,
+        transformSelection: Y,
+        isInvertible: Ge,
+        makeInvertible(y, b) {
+          return pe(y, b, f);
         },
-        stripInvertible: Ie,
-        invert: J,
-        invertWithDoc(_, w) {
-          return J(pe(_, w, f));
+        stripInvertible: Ce,
+        invert: Z,
+        invertWithDoc(y, b) {
+          return Z(pe(y, b, f));
         },
-        isNoop: (_) => _.length === 0
+        isNoop: (y) => y.length === 0
       };
     }
-    n.default = ve;
-  }(st)), st;
+    a.default = ve;
+  }(ct)), ct;
 }
-var Qe = {}, mt;
-function Ht() {
-  if (mt) return Qe;
-  mt = 1, Object.defineProperty(Qe, "__esModule", { value: !0 });
-  const n = at(), e = pt();
-  function t(i, s) {
+var rt = {}, Ct;
+function Jt() {
+  if (Ct) return rt;
+  Ct = 1, Object.defineProperty(rt, "__esModule", { value: !0 });
+  const a = ft(), e = ht();
+  function n(t, r) {
     return {
       // Returns the text content of the document
-      get: i,
+      get: t,
       // Returns the number of characters in the string
       getLength() {
-        return i().length;
+        return t().length;
       },
       // Insert the specified text at the given position in the document
-      insert(d, l, a) {
-        const E = e.strPosToUni(i(), d);
-        return s([E, l], a);
+      insert(u, o, l) {
+        const E = e.strPosToUni(t(), u);
+        return r([E, o], l);
       },
-      remove(d, l, a) {
-        const E = e.strPosToUni(i(), d);
-        return s([E, { d: l }], a);
+      remove(u, o, l) {
+        const E = e.strPosToUni(t(), u);
+        return r([E, { d: o }], l);
       },
       // When you use this API, you should implement these two methods
       // in your editing context.
       //onInsert: function(pos, text) {},
       //onRemove: function(pos, removedLength) {},
-      _onOp(d) {
-        n.eachOp(d, (l, a, E) => {
-          switch (typeof l) {
+      _onOp(u) {
+        a.eachOp(u, (o, l, E) => {
+          switch (typeof o) {
             case "string":
-              this.onInsert && this.onInsert(E, l);
+              this.onInsert && this.onInsert(E, o);
               break;
             case "object":
-              const W = n.dlen(l.d);
-              this.onRemove && this.onRemove(E, W);
+              const x = a.dlen(o.d);
+              this.onRemove && this.onRemove(E, x);
           }
         });
       },
@@ -616,31 +629,31 @@ function Ht() {
       onRemove: null
     };
   }
-  return Qe.default = t, t.provides = { text: !0 }, Qe;
+  return rt.default = n, n.provides = { text: !0 }, rt;
 }
-var bt;
-function Kt() {
-  return bt || (bt = 1, function(n) {
-    var e = Ce && Ce.__createBinding || (Object.create ? function(c, h, k, Z) {
-      Z === void 0 && (Z = k), Object.defineProperty(c, Z, { enumerable: !0, get: function() {
-        return h[k];
+var It;
+function Yt() {
+  return It || (It = 1, function(a) {
+    var e = Se && Se.__createBinding || (Object.create ? function(c, h, S, Y) {
+      Y === void 0 && (Y = S), Object.defineProperty(c, Y, { enumerable: !0, get: function() {
+        return h[S];
       } });
-    } : function(c, h, k, Z) {
-      Z === void 0 && (Z = k), c[Z] = h[k];
-    }), t = Ce && Ce.__setModuleDefault || (Object.create ? function(c, h) {
+    } : function(c, h, S, Y) {
+      Y === void 0 && (Y = S), c[Y] = h[S];
+    }), n = Se && Se.__setModuleDefault || (Object.create ? function(c, h) {
       Object.defineProperty(c, "default", { enumerable: !0, value: h });
     } : function(c, h) {
       c.default = h;
-    }), i = Ce && Ce.__importStar || function(c) {
+    }), t = Se && Se.__importStar || function(c) {
       if (c && c.__esModule) return c;
       var h = {};
-      if (c != null) for (var k in c) Object.hasOwnProperty.call(c, k) && e(h, c, k);
-      return t(h, c), h;
-    }, s = Ce && Ce.__importDefault || function(c) {
+      if (c != null) for (var S in c) Object.hasOwnProperty.call(c, S) && e(h, c, S);
+      return n(h, c), h;
+    }, r = Se && Se.__importDefault || function(c) {
       return c && c.__esModule ? c : { default: c };
     };
-    Object.defineProperty(n, "__esModule", { value: !0 }), n.type = n.remove = n.insert = void 0;
-    const d = pt(), l = i(at()), a = s(Ht()), E = {
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.type = a.remove = a.insert = void 0;
+    const u = ht(), o = t(ft()), l = r(Jt()), E = {
       create(c) {
         return c;
       },
@@ -652,854 +665,861 @@ function Kt() {
           throw Error("Invalid document snapshot: " + c);
         const h = [];
         return {
-          skip(k) {
-            let Z = d.uniToStrPos(c, k);
-            if (Z > c.length)
+          skip(S) {
+            let Y = u.uniToStrPos(c, S);
+            if (Y > c.length)
               throw Error("The op is too long for this document");
-            h.push(c.slice(0, Z)), c = c.slice(Z);
+            h.push(c.slice(0, Y)), c = c.slice(Y);
           },
-          append(k) {
-            h.push(k);
+          append(S) {
+            h.push(S);
           },
-          del(k) {
-            c = c.slice(d.uniToStrPos(c, k));
+          del(S) {
+            c = c.slice(u.uniToStrPos(c, S));
           },
           build() {
             return h.join("") + c;
           }
         };
       },
-      slice: l.uniSlice
-    }, W = l.default(E), O = Object.assign(Object.assign({}, W), { api: a.default });
-    n.type = O, n.insert = (c, h) => h.length === 0 ? [] : c === 0 ? [h] : [c, h], n.remove = (c, h) => l.dlen(h) === 0 ? [] : c === 0 ? [{ d: h }] : [c, { d: h }];
-    var o = at();
-    Object.defineProperty(n, "makeType", { enumerable: !0, get: function() {
-      return o.default;
+      slice: o.uniSlice
+    }, x = o.default(E), _ = Object.assign(Object.assign({}, x), { api: l.default });
+    a.type = _, a.insert = (c, h) => h.length === 0 ? [] : c === 0 ? [h] : [c, h], a.remove = (c, h) => o.dlen(h) === 0 ? [] : c === 0 ? [{ d: h }] : [c, { d: h }];
+    var s = ft();
+    Object.defineProperty(a, "makeType", { enumerable: !0, get: function() {
+      return s.default;
     } });
-  }(it)), it;
+  }(Se)), Se;
 }
-(function(n) {
-  var e = Ce && Ce.__importDefault || function(r) {
-    return r && r.__esModule ? r : {
-      default: r
+var Et;
+function Zt() {
+  return Et || (Et = 1, function(a) {
+    var e = Ze && Ze.__importDefault || function(i) {
+      return i && i.__esModule ? i : {
+        default: i
+      };
     };
-  };
-  Object.defineProperty(n, "__esModule", {
-    value: !0
-  }), n.editOp = n.replaceOp = n.insertOp = n.moveOp = n.removeOp = n.type = void 0;
-  const t = e(ct), i = e(dt), s = ft, d = ht;
-  function l(r, u) {
-    if (!r) throw new Error(u);
-  }
-  n.type = {
-    name: "json1",
-    uri: "http://sharejs.org/types/JSONv1",
-    readCursor: s.readCursor,
-    writeCursor: s.writeCursor,
-    create: (r) => r,
-    isNoop: (r) => r == null,
-    setDebug(r) {
-    },
-    registerSubtype: J,
-    checkValidOp: z,
-    normalize: H,
-    apply: De,
-    transformPosition: ue,
-    compose: ne,
-    tryTransform: nt,
-    transform: At,
-    makeInvertible: Ae,
-    invert: ae,
-    invertWithDoc: Dt,
-    RM_UNEXPECTED_CONTENT: d.ConflictType.RM_UNEXPECTED_CONTENT,
-    DROP_COLLISION: d.ConflictType.DROP_COLLISION,
-    BLACKHOLE: d.ConflictType.BLACKHOLE,
-    transformNoConflict: (r, u, y) => _t(() => !0, r, u, y),
-    typeAllowingConflictsPred: (r) => Object.assign(Object.assign({}, n.type), {
-      transform: (u, y, D) => _t(r, u, y, D)
-    })
-  };
-  const a = (r) => r ? r.getComponent() : null;
-  function E(r) {
-    return r && typeof r == "object" && !Array.isArray(r);
-  }
-  const W = (r) => Array.isArray(r) ? r.slice() : r !== null && typeof r == "object" ? Object.assign({}, r) : r, O = (r) => r && (r.p != null || r.r !== void 0), o = (r) => r && (r.d != null || r.i !== void 0);
-  function c(r, u) {
-    return l(r != null), typeof u == "number" ? (l(Array.isArray(r), "Invalid key - child is not an array"), (r = r.slice()).splice(u, 1)) : (l(E(r), "Invalid key - child is not an object"), delete (r = Object.assign({}, r))[u]), r;
-  }
-  function h(r, u, y) {
-    return typeof u == "number" ? (l(r != null, "Container is missing for key"), l(Array.isArray(r), "Cannot use numerical key for object container"), l(r.length >= u, "Cannot insert into out of bounds index"), r.splice(u, 0, y)) : (l(E(r), "Cannot insert into missing item"), l(r[u] === void 0, "Trying to overwrite value at key. Your op needs to remove it first"), r[u] = y), y;
-  }
-  n.removeOp = (r, u = !0) => s.writeCursor().writeAtPath(r, "r", u).get(), n.moveOp = (r, u) => s.writeCursor().writeMove(r, u).get(), n.insertOp = (r, u) => s.writeCursor().writeAtPath(r, "i", u).get(), n.replaceOp = (r, u, y) => s.writeCursor().at(r, (D) => {
-    D.write("r", u), D.write("i", y);
-  }).get(), n.editOp = (r, u, y, D = !1) => s.writeCursor().at(r, (m) => _(m, u, y, D)).get();
-  const k = (r, u) => r != null && (typeof u == "number" ? Array.isArray(r) : typeof r == "object"), Z = (r, u) => k(r, u) ? r[u] : void 0, pe = {};
-  function J(r) {
-    let u = r.type ? r.type : r;
-    u.name && (pe[u.name] = u), u.uri && (pe[u.uri] = u);
-  }
-  const Ie = (r) => {
-    const u = pe[r];
-    if (u) return u;
-    throw Error("Missing type: " + r);
-  };
-  J(Kt());
-  const xe = (r, u) => r + u;
-  J({
-    name: "number",
-    apply: xe,
-    compose: xe,
-    invert: (r) => -r,
-    transform: (r) => r
-  });
-  const ve = (r) => r == null ? null : r.et ? Ie(r.et) : r.es ? pe["text-unicode"] : r.ena != null ? pe.number : null, f = (r) => r.es ? r.es : r.ena != null ? r.ena : r.e, _ = (r, u, y, D = !1) => {
-    const [m, C] = typeof u == "string" ? [Ie(u), u] : [u, u.name];
-    !D && m.isNoop && m.isNoop(y) || (C === "number" ? r.write("ena", y) : C === "text-unicode" ? r.write("es", y) : (r.write("et", C), r.write("e", y)));
-  };
-  function w(r) {
-    l(typeof r == "number"), l(r >= 0), l(r === (0 | r));
-  }
-  function L(r) {
-    typeof r == "number" ? w(r) : l(typeof r == "string");
-  }
-  function z(r) {
-    if (r === null) return;
-    const u = /* @__PURE__ */ new Set(), y = /* @__PURE__ */ new Set(), D = (C) => {
-      let $ = !0, j = !1;
-      for (let p in C) {
-        const v = C[p];
-        if ($ = !1, l(p === "p" || p === "r" || p === "d" || p === "i" || p === "e" || p === "es" || p === "ena" || p === "et", "Invalid component item '" + p + "'"), p === "p") w(v), l(!u.has(v)), u.add(v), l(C.r === void 0);
-        else if (p === "d") w(v), l(!y.has(v)), y.add(v), l(C.i === void 0);
-        else if (p === "e" || p === "es" || p === "ena") {
-          l(!j), j = !0;
-          const b = ve(C);
-          l(b, "Missing type in edit"), b.checkValidOp && b.checkValidOp(f(C));
+    Object.defineProperty(a, "__esModule", {
+      value: !0
+    }), a.editOp = a.replaceOp = a.insertOp = a.moveOp = a.removeOp = a.type = void 0;
+    const n = e(zt()), t = e(Xt()), r = At(), u = Mt();
+    function o(i, d) {
+      if (!i) throw new Error(d);
+    }
+    a.type = {
+      name: "json1",
+      uri: "http://sharejs.org/types/JSONv1",
+      readCursor: r.readCursor,
+      writeCursor: r.writeCursor,
+      create: (i) => i,
+      isNoop: (i) => i == null,
+      setDebug(i) {
+      },
+      registerSubtype: Z,
+      checkValidOp: z,
+      normalize: q,
+      apply: Ee,
+      transformPosition: ce,
+      compose: ne,
+      tryTransform: st,
+      transform: kt,
+      makeInvertible: De,
+      invert: le,
+      invertWithDoc: Ut,
+      RM_UNEXPECTED_CONTENT: u.ConflictType.RM_UNEXPECTED_CONTENT,
+      DROP_COLLISION: u.ConflictType.DROP_COLLISION,
+      BLACKHOLE: u.ConflictType.BLACKHOLE,
+      transformNoConflict: (i, d, m) => gt(() => !0, i, d, m),
+      typeAllowingConflictsPred: (i) => Object.assign(Object.assign({}, a.type), {
+        transform: (d, m, D) => gt(i, d, m, D)
+      })
+    };
+    const l = (i) => i ? i.getComponent() : null;
+    function E(i) {
+      return i && typeof i == "object" && !Array.isArray(i);
+    }
+    const x = (i) => Array.isArray(i) ? i.slice() : i !== null && typeof i == "object" ? Object.assign({}, i) : i, _ = (i) => i && (i.p != null || i.r !== void 0), s = (i) => i && (i.d != null || i.i !== void 0);
+    function c(i, d) {
+      return o(i != null), typeof d == "number" ? (o(Array.isArray(i), "Invalid key - child is not an array"), (i = i.slice()).splice(d, 1)) : (o(E(i), "Invalid key - child is not an object"), delete (i = Object.assign({}, i))[d]), i;
+    }
+    function h(i, d, m) {
+      return typeof d == "number" ? (o(i != null, "Container is missing for key"), o(Array.isArray(i), "Cannot use numerical key for object container"), o(i.length >= d, "Cannot insert into out of bounds index"), i.splice(d, 0, m)) : (o(E(i), "Cannot insert into missing item"), o(i[d] === void 0, "Trying to overwrite value at key. Your op needs to remove it first"), i[d] = m), m;
+    }
+    a.removeOp = (i, d = !0) => r.writeCursor().writeAtPath(i, "r", d).get(), a.moveOp = (i, d) => r.writeCursor().writeMove(i, d).get(), a.insertOp = (i, d) => r.writeCursor().writeAtPath(i, "i", d).get(), a.replaceOp = (i, d, m) => r.writeCursor().at(i, (D) => {
+      D.write("r", d), D.write("i", m);
+    }).get(), a.editOp = (i, d, m, D = !1) => r.writeCursor().at(i, (O) => y(O, d, m, D)).get();
+    const S = (i, d) => i != null && (typeof d == "number" ? Array.isArray(i) : typeof i == "object"), Y = (i, d) => S(i, d) ? i[d] : void 0, pe = {};
+    function Z(i) {
+      let d = i.type ? i.type : i;
+      d.name && (pe[d.name] = d), d.uri && (pe[d.uri] = d);
+    }
+    const Ce = (i) => {
+      const d = pe[i];
+      if (d) return d;
+      throw Error("Missing type: " + i);
+    };
+    Z(Yt());
+    const Ge = (i, d) => i + d;
+    Z({
+      name: "number",
+      apply: Ge,
+      compose: Ge,
+      invert: (i) => -i,
+      transform: (i) => i
+    });
+    const ve = (i) => i == null ? null : i.et ? Ce(i.et) : i.es ? pe["text-unicode"] : i.ena != null ? pe.number : null, f = (i) => i.es ? i.es : i.ena != null ? i.ena : i.e, y = (i, d, m, D = !1) => {
+      const [O, I] = typeof d == "string" ? [Ce(d), d] : [d, d.name];
+      !D && O.isNoop && O.isNoop(m) || (I === "number" ? i.write("ena", m) : I === "text-unicode" ? i.write("es", m) : (i.write("et", I), i.write("e", m)));
+    };
+    function b(i) {
+      o(typeof i == "number"), o(i >= 0), o(i === (0 | i));
+    }
+    function L(i) {
+      typeof i == "number" ? b(i) : o(typeof i == "string");
+    }
+    function z(i) {
+      if (i === null) return;
+      const d = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Set(), D = (I) => {
+        let R = !0, $ = !1;
+        for (let p in I) {
+          const v = I[p];
+          if (R = !1, o(p === "p" || p === "r" || p === "d" || p === "i" || p === "e" || p === "es" || p === "ena" || p === "et", "Invalid component item '" + p + "'"), p === "p") b(v), o(!d.has(v)), d.add(v), o(I.r === void 0);
+          else if (p === "d") b(v), o(!m.has(v)), m.add(v), o(I.i === void 0);
+          else if (p === "e" || p === "es" || p === "ena") {
+            o(!$), $ = !0;
+            const w = ve(I);
+            o(w, "Missing type in edit"), w.checkValidOp && w.checkValidOp(f(I));
+          }
         }
-      }
-      l(!$);
-    }, m = (C, $, j) => {
-      if (!Array.isArray(C)) throw Error("Op must be null or a list");
-      if (C.length === 0) throw Error("Empty descent");
-      $ || L(C[0]);
-      let p = 1, v = 0, b = 0;
-      for (let I = 0; I < C.length; I++) {
-        const T = C[I];
-        if (l(T != null), Array.isArray(T)) {
-          const G = m(T, !1);
-          if (v) {
-            const g = typeof b, N = typeof G;
-            g === N ? l(b < G, "descent keys are not in order") : l(g === "number" && N === "string");
+        o(!R);
+      }, O = (I, R, $) => {
+        if (!Array.isArray(I)) throw Error("Op must be null or a list");
+        if (I.length === 0) throw Error("Empty descent");
+        R || L(I[0]);
+        let p = 1, v = 0, w = 0;
+        for (let C = 0; C < I.length; C++) {
+          const N = I[C];
+          if (o(N != null), Array.isArray(N)) {
+            const B = O(N, !1);
+            if (v) {
+              const g = typeof w, U = typeof B;
+              g === U ? o(w < B, "descent keys are not in order") : o(g === "number" && U === "string");
+            }
+            w = B, v++, p = 3;
+          } else typeof N == "object" ? (o(p === 1, `Prev not scalar - instead ${p}`), D(N), p = 2) : (o(p !== 3), L(N), o(r.isValidPathItem(N), "Invalid path key"), p = 1);
+        }
+        return o(v !== 1, "Operation makes multiple descents. Remove some []"), o(p === 2 || p === 3), I[0];
+      };
+      O(i, !0), o(d.size === m.size, "Mismatched picks and drops in op");
+      for (let I = 0; I < d.size; I++) o(d.has(I)), o(m.has(I));
+    }
+    function q(i) {
+      let d = 0, m = [];
+      const D = r.writeCursor();
+      return D.mergeTree(i, (O, I) => {
+        const R = ve(O);
+        if (R) {
+          const p = f(O);
+          y(I, R, R.normalize ? R.normalize(p) : p);
+        }
+        for (const p of ["r", "p", "i", "d"]) if (O[p] !== void 0) {
+          const v = p === "p" || p === "d" ? ($ = O[p], m[$] == null && (m[$] = d++), m[$]) : O[p];
+          I.write(p, v);
+        }
+        var $;
+      }), D.get();
+    }
+    function Ee(i, d) {
+      if (z(d), d === null) return i;
+      const m = [];
+      return function D(O, I) {
+        let R = O, $ = 0, p = {
+          root: O
+        }, v = 0, w = p, C = "root";
+        function N() {
+          for (; v < $; v++) {
+            let B = I[v];
+            typeof B != "object" && (o(S(w, C)), w = w[C] = x(w[C]), C = B);
           }
-          b = G, v++, p = 3;
-        } else typeof T == "object" ? (l(p === 1, `Prev not scalar - instead ${p}`), D(T), p = 2) : (l(p !== 3), L(T), l(s.isValidPathItem(T), "Invalid path key"), p = 1);
-      }
-      return l(v !== 1, "Operation makes multiple descents. Remove some []"), l(p === 2 || p === 3), C[0];
-    };
-    m(r, !0), l(u.size === y.size, "Mismatched picks and drops in op");
-    for (let C = 0; C < u.size; C++) l(u.has(C)), l(y.has(C));
-  }
-  function H(r) {
-    let u = 0, y = [];
-    const D = s.writeCursor();
-    return D.mergeTree(r, (m, C) => {
-      const $ = ve(m);
-      if ($) {
-        const p = f(m);
-        _(C, $, $.normalize ? $.normalize(p) : p);
-      }
-      for (const p of ["r", "p", "i", "d"]) if (m[p] !== void 0) {
-        const v = p === "p" || p === "d" ? (j = m[p], y[j] == null && (y[j] = u++), y[j]) : m[p];
-        C.write(p, v);
-      }
-      var j;
-    }), D.get();
-  }
-  function De(r, u) {
-    if (z(u), u === null) return r;
-    const y = [];
-    return function D(m, C) {
-      let $ = m, j = 0, p = {
-        root: m
-      }, v = 0, b = p, I = "root";
-      function T() {
-        for (; v < j; v++) {
-          let G = C[v];
-          typeof G != "object" && (l(k(b, I)), b = b[I] = W(b[I]), I = G);
         }
-      }
-      for (; j < C.length; j++) {
-        const G = C[j];
-        if (Array.isArray(G)) {
-          const g = D($, G);
-          g !== $ && g !== void 0 && (T(), $ = b[I] = g);
-        } else if (typeof G == "object") {
-          G.d != null ? (T(), $ = h(b, I, y[G.d])) : G.i !== void 0 && (T(), $ = h(b, I, G.i));
-          const g = ve(G);
-          if (g) T(), $ = b[I] = g.apply($, f(G));
-          else if (G.e !== void 0) throw Error("Subtype " + G.et + " undefined");
-        } else $ = Z($, G);
-      }
-      return p.root;
-    }(r = function D(m, C) {
-      const $ = [];
-      let j = 0;
-      for (; j < C.length; j++) {
-        const I = C[j];
-        if (Array.isArray(I)) break;
-        typeof I != "object" && ($.push(m), m = Z(m, I));
-      }
-      for (let I = C.length - 1; I >= j; I--) m = D(m, C[I]);
-      for (--j; j >= 0; j--) {
-        const I = C[j];
-        if (typeof I != "object") {
-          const T = $.pop();
-          m = m === Z(T, I) ? T : m === void 0 ? c(T, I) : (v = I, b = m, (p = W(p = T))[v] = b, p);
-        } else O(I) && (l(m !== void 0, "Cannot pick up or remove undefined"), I.p != null && (y[I.p] = m), m = void 0);
-      }
-      var p, v, b;
-      return m;
-    }(r, u), u);
-  }
-  function ue(r, u) {
-    r = r.slice(), z(u);
-    const y = s.readCursor(u);
-    let D, m, C = !1;
-    const $ = [];
-    for (let p = 0; ; p++) {
-      const v = r[p], b = y.getComponent();
-      if (b && (b.r !== void 0 ? C = !0 : b.p != null && (C = !1, D = b.p, m = p)), p >= r.length) break;
-      let I = 0;
-      const T = s.advancer(y, void 0, (g, N) => {
-        O(N) && I++;
-      });
-      $.unshift(T);
-      const G = T(v);
-      if (typeof v == "number" && (r[p] -= I), !G) break;
+        for (; $ < I.length; $++) {
+          const B = I[$];
+          if (Array.isArray(B)) {
+            const g = D(R, B);
+            g !== R && g !== void 0 && (N(), R = w[C] = g);
+          } else if (typeof B == "object") {
+            B.d != null ? (N(), R = h(w, C, m[B.d])) : B.i !== void 0 && (N(), R = h(w, C, B.i));
+            const g = ve(B);
+            if (g) N(), R = w[C] = g.apply(R, f(B));
+            else if (B.e !== void 0) throw Error("Subtype " + B.et + " undefined");
+          } else R = Y(R, B);
+        }
+        return p.root;
+      }(i = function D(O, I) {
+        const R = [];
+        let $ = 0;
+        for (; $ < I.length; $++) {
+          const C = I[$];
+          if (Array.isArray(C)) break;
+          typeof C != "object" && (R.push(O), O = Y(O, C));
+        }
+        for (let C = I.length - 1; C >= $; C--) O = D(O, I[C]);
+        for (--$; $ >= 0; $--) {
+          const C = I[$];
+          if (typeof C != "object") {
+            const N = R.pop();
+            O = O === Y(N, C) ? N : O === void 0 ? c(N, C) : (v = C, w = O, (p = x(p = N))[v] = w, p);
+          } else _(C) && (o(O !== void 0, "Cannot pick up or remove undefined"), C.p != null && (m[C.p] = O), O = void 0);
+        }
+        var p, v, w;
+        return O;
+      }(i, d), d);
     }
-    if ($.forEach((p) => p.end()), C) return null;
-    const j = () => {
-      let p = 0;
-      if (D != null) {
-        const v = y.getPath();
-        p = v.length, r = v.concat(r.slice(m));
+    function ce(i, d) {
+      i = i.slice(), z(d);
+      const m = r.readCursor(d);
+      let D, O, I = !1;
+      const R = [];
+      for (let p = 0; ; p++) {
+        const v = i[p], w = m.getComponent();
+        if (w && (w.r !== void 0 ? I = !0 : w.p != null && (I = !1, D = w.p, O = p)), p >= i.length) break;
+        let C = 0;
+        const N = r.advancer(m, void 0, (g, U) => {
+          _(U) && C++;
+        });
+        R.unshift(N);
+        const B = N(v);
+        if (typeof v == "number" && (i[p] -= C), !B) break;
       }
-      for (; p < r.length; p++) {
-        const v = r[p], b = a(y), I = ve(b);
-        if (I) {
-          const g = f(b);
-          I.transformPosition && (r[p] = I.transformPosition(r[p], g));
-          break;
+      if (R.forEach((p) => p.end()), I) return null;
+      const $ = () => {
+        let p = 0;
+        if (D != null) {
+          const v = m.getPath();
+          p = v.length, i = v.concat(i.slice(O));
         }
-        let T = 0;
-        const G = s.advancer(y, (g, N) => o(N) ? ~(g - T) : g - T, (g, N) => {
-          o(N) && T++;
-        })(v);
-        if (typeof v == "number" && (r[p] += T), !G) break;
-      }
-    };
-    return D != null ? y.eachDrop(null, (p) => {
-      p === D && j();
-    }) : j(), r;
-  }
-  function ne(r, u) {
-    if (z(r), z(u), r == null) return u;
-    if (u == null) return r;
-    let y = 0;
-    const D = s.readCursor(r), m = s.readCursor(u), C = s.writeCursor(), $ = [], j = [], p = [], v = [], b = [], I = [], T = /* @__PURE__ */ new Set();
-    D.traverse(null, (g) => {
-      g.p != null && (p[g.p] = D.clone());
-    }), m.traverse(null, (g) => {
-      g.d != null && (v[g.d] = m.clone());
-    });
-    const G = s.writeCursor();
-    return function g(N, re, te, K, se, Te, me, _e) {
-      l(re || te);
-      const oe = a(re), Pe = a(te), Me = !!Pe && Pe.r !== void 0, Le = !!oe && oe.i !== void 0, Ue = oe ? oe.d : null, Ee = Pe ? Pe.p : null, $e = (Te || Me) && Ee == null;
-      if (Ee != null) K = v[Ee], me = j[Ee] = new s.WriteCursor();
-      else if (Pe && Pe.r !== void 0) K = null;
-      else {
-        const P = a(K);
-        P && P.d != null && (K = null);
-      }
-      const Q = a(K);
-      if (Ue != null) if (N = p[Ue], _e = $[Ue] = new s.WriteCursor(), $e) Te && !Me && _e.write("r", !0);
-      else {
-        const P = b[Ue] = y++;
-        me.write("d", P);
-      }
-      else if (oe && oe.i !== void 0) N = null;
-      else {
-        const P = a(N);
-        P && P.p != null && (N = null);
-      }
-      let U;
-      Le ? (l(se === void 0), U = oe.i) : U = se;
-      const B = (Ee == null ? !Le || Te || Me : U === void 0) ? null : me.getComponent();
-      if (Ee != null) {
-        if (!(se !== void 0 || Le)) {
-          const P = Ue != null ? b[Ue] : y++;
-          I[Ee] = P, _e.write("p", P);
+        for (; p < i.length; p++) {
+          const v = i[p], w = l(m), C = ve(w);
+          if (C) {
+            const g = f(w);
+            C.transformPosition && (i[p] = C.transformPosition(i[p], g));
+            break;
+          }
+          let N = 0;
+          const B = r.advancer(m, (g, U) => s(U) ? ~(g - N) : g - N, (g, U) => {
+            s(U) && N++;
+          })(v);
+          if (typeof v == "number" && (i[p] += N), !B) break;
         }
-      } else Me && (Le || se !== void 0 || (Pe.r, _e.write("r", Pe.r)));
-      const M = $e ? null : ve(oe), A = ve(Q);
-      if ((M || A) && (M && M.name, A && A.name), M && A) {
-        l(M === A);
-        const P = f(oe), x = f(Q), he = M.compose(P, x);
-        _(me, M, he), T.add(Q);
-      } else M ? _(me, M, f(oe)) : A && (_(me, A, f(Q)), T.add(Q));
-      const R = typeof U == "object" && U != null;
-      let X = !1, Y = 0, ee = 0, fe = 0, de = 0, le = 0;
-      const ye = s.advancer(K, (P, x) => o(x) ? de - P - 1 : P - de, (P, x) => {
-        o(x) && de++;
-      }), q = s.advancer(N, (P, x) => O(x) ? Y - P - 1 : P - Y, (P, x) => {
-        O(x) && Y++;
+      };
+      return D != null ? m.eachDrop(null, (p) => {
+        p === D && $();
+      }) : $(), i;
+    }
+    function ne(i, d) {
+      if (z(i), z(d), i == null) return d;
+      if (d == null) return i;
+      let m = 0;
+      const D = r.readCursor(i), O = r.readCursor(d), I = r.writeCursor(), R = [], $ = [], p = [], v = [], w = [], C = [], N = /* @__PURE__ */ new Set();
+      D.traverse(null, (g) => {
+        g.p != null && (p[g.p] = D.clone());
+      }), O.traverse(null, (g) => {
+        g.d != null && (v[g.d] = O.clone());
       });
-      if (s.eachChildOf(re, te, (P, x, he) => {
-        let be, We, He = P, Ne = P, Ye = P;
-        if (typeof P == "number") {
-          let Oe = P + fe;
-          We = ye(Oe), Ne = Oe + de;
-          let ce = P + ee;
-          be = q(ce), o(a(We)) && (be = null), He = ce + Y, Ye = P + le, l(He >= 0, "p1PickKey is negative"), l(Ne >= 0, "p2DropKey is negative");
-          const Re = o(a(x)), Ge = O(a(he));
-          (Re || Ge && !$e) && le--, Re && ee--, Ge && fe--;
-        } else be = q(P), We = ye(P);
-        _e.descend(He), me.descend(Ne);
-        const ze = R && !o(a(x)) ? U[Ye] : void 0, Se = g(be, x, he, We, ze, $e, me, _e);
-        var je, S, ie;
-        R && !$e ? ze !== Se && (X || (U = Array.isArray(U) ? U.slice() : Object.assign({}, U), X = !0), je = U, ie = Se, typeof (S = Ye) == "number" ? (l(Array.isArray(je)), l(S < je.length)) : (l(!Array.isArray(je)), l(je[S] !== void 0)), ie === void 0 ? typeof S == "number" ? je.splice(S, 1) : delete je[S] : je[S] = ie) : l(Se === void 0), me.ascend(), _e.ascend();
-      }), q.end(), ye.end(), B != null) B.i = U;
-      else if (!Te && !Me && Ee == null) return U;
-    }(D, D.clone(), m, m.clone(), void 0, !1, C, G), C.reset(), C.mergeTree(G.get()), C.reset(), C.get(), $.map((g) => g.get()), j.map((g) => g.get()), D.traverse(C, (g, N) => {
-      const re = g.p;
-      if (re != null) {
-        const te = b[re];
-        te != null && N.write("p", te);
-        const K = $[re];
-        K && K.get(), K && N.mergeTree(K.get());
-      } else g.r !== void 0 && N.write("r", g.r);
-    }), C.reset(), C.get(), m.traverse(C, (g, N) => {
-      const re = g.d;
-      if (re != null) {
-        const K = I[re];
-        K != null && N.write("d", K);
-        const se = j[re];
-        se && N.mergeTree(se.get());
-      } else g.i !== void 0 && N.write("i", g.i);
-      const te = ve(g);
-      te && !T.has(g) && _(N, te, f(g));
-    }), C.get();
-  }
-  function ae(r) {
-    if (r == null) return null;
-    const u = new s.ReadCursor(r), y = new s.WriteCursor();
-    let D;
-    const m = [], C = [];
-    return function $(j, p, v) {
-      const b = j.getComponent();
-      let I, T = !1;
-      if (b) {
-        b.p != null && (p.write("d", b.p), m[b.p] = j.clone()), b.r !== void 0 && p.write("i", b.r), b.d != null && (p.write("p", b.d), v = void 0), b.i !== void 0 && (v = I = b.i);
-        const g = ve(b);
-        g && (v === void 0 ? (D || (D = /* @__PURE__ */ new Set()), D.add(b)) : (f(b), v = g.apply(v, f(b)), T = !0));
-      }
-      let G = 0;
-      for (const g of j) {
-        p.descend(g);
-        const N = typeof g == "number" ? g - G : g, re = Z(v, N);
-        o(j.getComponent()) && G++;
-        const te = $(j, p, re);
-        if (v !== void 0 && te !== void 0) {
-          if (T || (T = !0, v = W(v)), !k(v, N)) throw Error("Cannot modify child - invalid operation");
-          v[N] = te;
+      const B = r.writeCursor();
+      return function g(U, re, te, K, se, Ne, Oe, ye) {
+        o(re || te);
+        const oe = l(re), Pe = l(te), Ae = !!Pe && Pe.r !== void 0, Le = !!oe && oe.i !== void 0, Te = oe ? oe.d : null, Ie = Pe ? Pe.p : null, Re = (Ne || Ae) && Ie == null;
+        if (Ie != null) K = v[Ie], Oe = $[Ie] = new r.WriteCursor();
+        else if (Pe && Pe.r !== void 0) K = null;
+        else {
+          const T = l(K);
+          T && T.d != null && (K = null);
         }
-        p.ascend();
-      }
-      if (I === void 0) return T ? v : void 0;
-      p.write("r", v);
-    }(u, y, void 0), D && (y.reset(), function $(j, p, v) {
-      const b = p.getComponent();
-      if (b) {
-        const g = b.d;
-        if (g != null && (j = m[g], v = C[g] = s.writeCursor()), D.has(b)) {
-          const N = ve(b);
-          if (!N.invert) throw Error(`Cannot invert subtype ${N.name}`);
-          _(v, N, N.invert(f(b)));
+        const Q = l(K);
+        if (Te != null) if (U = p[Te], ye = R[Te] = new r.WriteCursor(), Re) Ne && !Ae && ye.write("r", !0);
+        else {
+          const T = w[Te] = m++;
+          Oe.write("d", T);
         }
-      }
-      let I = 0, T = 0;
-      const G = s.advancer(j, (g, N) => O(N) ? I - g - 1 : g - I, (g, N) => {
-        O(N) && I++;
-      });
-      for (const g of p) if (typeof g == "number") {
-        const N = g - T, re = G(N), te = N + I;
-        v.descend(te), $(re, p, v), o(p.getComponent()) && T++, v.ascend();
-      } else v.descend(g), $(G(g), p, v), v.ascend();
-      G.end();
-    }(u.clone(), u, y), C.length && (y.reset(), u.traverse(y, ($, j) => {
-      const p = $.p;
-      if (p != null) {
-        const v = C[p];
-        v && v.get(), v && j.mergeTree(v.get());
-      }
-    }))), y.get();
-  }
-  const ge = (r, u) => r.some((y) => typeof y == "object" && (Array.isArray(y) ? ge(y, u) : u(y)));
-  function Ae(r, u) {
-    if (r == null || !ge(r, (p) => {
-      var v;
-      return p.r !== void 0 || ((v = ve(p)) === null || v === void 0 ? void 0 : v.makeInvertible) != null;
-    })) return r;
-    const y = new s.ReadCursor(r), D = new s.WriteCursor();
-    let m = !1;
-    const C = [], $ = [], j = (p, v, b) => {
-      const I = p.getComponent();
-      let T = !1;
-      if (I) {
-        I.d != null && v.write("d", I.d), I.i !== void 0 && v.write("i", I.i);
-        const g = I.p;
-        if (g != null && (C[g] = p.clone(), l(b !== void 0, "Operation picks up at an invalid key"), $[g] = b, v.write("p", I.p)), I.r !== void 0 && b === void 0) throw Error("Invalid doc / op in makeInvertible: removed item missing from doc");
-        const N = ve(I);
-        N && (N.makeInvertible ? m = !0 : _(v, N, f(I), !0));
-      }
-      let G = 0;
-      for (const g of p) {
-        v.descend(g);
-        const N = typeof g == "number" ? g - G : g, re = Z(b, N), te = j(p, v, re);
-        re !== te && (T || (T = !0, b = W(b)), te === void 0 ? (b = c(b, N), typeof g == "number" && G++) : b[N] = te), v.ascend();
-      }
-      return I && (I.r !== void 0 ? (v.write("r", i.default(b)), b = void 0) : I.p != null && (b = void 0)), b;
-    };
-    return j(y, D, u), D.get(), m && (D.reset(), function p(v, b, I, T, G) {
-      const g = b.getComponent();
-      if (g) {
-        g.i !== void 0 ? (T = g.i, G = !0) : g.d != null && (T = $[g.d], v = C[g.d], G = !1, g.d);
-        let K = ve(g);
-        if (K && K.makeInvertible) {
-          const se = f(g);
-          _(I, K, K.makeInvertible(se, T), !0);
+        else if (oe && oe.i !== void 0) U = null;
+        else {
+          const T = l(U);
+          T && T.p != null && (U = null);
         }
-      }
-      let N = 0, re = 0;
-      const te = s.advancer(v, (K, se) => O(se) ? N - K - 1 : K - N, (K, se) => {
-        O(se) && N++;
-      });
-      for (const K of b) if (typeof K == "number") {
-        const se = K - re, Te = te(se), me = se + N, _e = Z(T, G ? se : me);
-        I.descend(K), p(Te, b, I, _e, G), o(b.getComponent()) && re++, I.ascend();
-      } else {
-        const se = Z(T, K);
-        I.descend(K), p(te(K), b, I, se, G), I.ascend();
-      }
-      te.end();
-    }(y.clone(), y, D, u, !1)), D.get();
-  }
-  function Dt(r, u) {
-    return ae(Ae(r, u));
-  }
-  const tt = (r) => {
-    if (r == null) return null;
-    const u = r.slice();
-    for (let y = 0; y < r.length; y++) {
-      const D = u[y];
-      Array.isArray(D) && (u[y] = tt(D));
+        let A;
+        Le ? (o(se === void 0), A = oe.i) : A = se;
+        const W = (Ie == null ? !Le || Ne || Ae : A === void 0) ? null : Oe.getComponent();
+        if (Ie != null) {
+          if (!(se !== void 0 || Le)) {
+            const T = Te != null ? w[Te] : m++;
+            C[Ie] = T, ye.write("p", T);
+          }
+        } else Ae && (Le || se !== void 0 || (Pe.r, ye.write("r", Pe.r)));
+        const M = Re ? null : ve(oe), P = ve(Q);
+        if ((M || P) && (M && M.name, P && P.name), M && P) {
+          o(M === P);
+          const T = f(oe), G = f(Q), he = M.compose(T, G);
+          y(Oe, M, he), N.add(Q);
+        } else M ? y(Oe, M, f(oe)) : P && (y(Oe, P, f(Q)), N.add(Q));
+        const k = typeof A == "object" && A != null;
+        let X = !1, J = 0, ee = 0, fe = 0, de = 0, ae = 0;
+        const me = r.advancer(K, (T, G) => s(G) ? de - T - 1 : T - de, (T, G) => {
+          s(G) && de++;
+        }), H = r.advancer(U, (T, G) => _(G) ? J - T - 1 : T - J, (T, G) => {
+          _(G) && J++;
+        });
+        if (r.eachChildOf(re, te, (T, G, he) => {
+          let we, xe, qe = T, Me = T, Ye = T;
+          if (typeof T == "number") {
+            let _e = T + fe;
+            xe = me(_e), Me = _e + de;
+            let ue = T + ee;
+            we = H(ue), s(l(xe)) && (we = null), qe = ue + J, Ye = T + ae, o(qe >= 0, "p1PickKey is negative"), o(Me >= 0, "p2DropKey is negative");
+            const Ue = s(l(G)), Be = _(l(he));
+            (Ue || Be && !Re) && ae--, Ue && ee--, Be && fe--;
+          } else we = H(T), xe = me(T);
+          ye.descend(qe), Oe.descend(Me);
+          const Xe = k && !s(l(G)) ? A[Ye] : void 0, je = g(we, G, he, xe, Xe, Re, Oe, ye);
+          var $e, j, ie;
+          k && !Re ? Xe !== je && (X || (A = Array.isArray(A) ? A.slice() : Object.assign({}, A), X = !0), $e = A, ie = je, typeof (j = Ye) == "number" ? (o(Array.isArray($e)), o(j < $e.length)) : (o(!Array.isArray($e)), o($e[j] !== void 0)), ie === void 0 ? typeof j == "number" ? $e.splice(j, 1) : delete $e[j] : $e[j] = ie) : o(je === void 0), Oe.ascend(), ye.ascend();
+        }), H.end(), me.end(), W != null) W.i = A;
+        else if (!Ne && !Ae && Ie == null) return A;
+      }(D, D.clone(), O, O.clone(), void 0, !1, I, B), I.reset(), I.mergeTree(B.get()), I.reset(), I.get(), R.map((g) => g.get()), $.map((g) => g.get()), D.traverse(I, (g, U) => {
+        const re = g.p;
+        if (re != null) {
+          const te = w[re];
+          te != null && U.write("p", te);
+          const K = R[re];
+          K && K.get(), K && U.mergeTree(K.get());
+        } else g.r !== void 0 && U.write("r", g.r);
+      }), I.reset(), I.get(), O.traverse(I, (g, U) => {
+        const re = g.d;
+        if (re != null) {
+          const K = C[re];
+          K != null && U.write("d", K);
+          const se = $[re];
+          se && U.mergeTree(se.get());
+        } else g.i !== void 0 && U.write("i", g.i);
+        const te = ve(g);
+        te && !N.has(g) && y(U, te, f(g));
+      }), I.get();
     }
-    return u;
-  };
-  function nt(r, u, y) {
-    l(y === "left" || y === "right", "Direction must be left or right");
-    const D = y === "left" ? 0 : 1;
-    if (u == null) return {
-      ok: !0,
-      result: r
-    };
-    z(r), z(u);
-    let m = null;
-    const C = [], $ = [], j = [], p = [], v = [], b = [], I = [], T = [], G = [], g = [], N = [], re = [], te = [], K = [], se = [];
-    let Te = 0;
-    const me = s.readCursor(r), _e = s.readCursor(u), oe = s.writeCursor();
-    if (function Q(U, B = null, M) {
-      const A = a(B);
-      A && (A.r !== void 0 ? M = B.clone() : A.p != null && (M = null, b[A.p] = U.clone()));
-      const R = U.getComponent();
-      let X;
-      R && (X = R.p) != null && (v[X] = B ? B.clone() : null, j[X] = U.clone(), M && (g[X] = !0, G[X] = M), A && A.p != null && (K[X] = A.p));
-      const Y = s.advancer(B);
-      for (const ee of U) Q(U, Y(ee), M);
-      Y.end();
-    }(_e, me, null), function Q(U, B, M, A, R) {
-      const X = M.getComponent();
-      let Y, ee = !1;
-      X && ((Y = X.d) != null ? (p[Y] = M.clone(), A != null && (se[A] == null && (se[A] = []), se[A].push(Y)), U = v[Y] || null, B = j[Y] || null, g[Y] ? (R && (N[Y] = !0), R = G[Y] || null) : !R || D !== 1 && K[Y] != null || m == null && (m = {
-        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-        op1: n.removeOp(R.getPath()),
-        op2: n.moveOp(B.getPath(), M.getPath())
-      }), ee = !0) : X.i !== void 0 && (U = B = null, ee = !0, R && m == null && (m = {
-        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-        op1: n.removeOp(R.getPath()),
-        op2: n.insertOp(M.getPath(), X.i)
-      })));
-      const fe = a(U);
-      fe && (fe.r !== void 0 ? R = U.clone() : fe.p != null && (fe.p, A = fe.p, R = null));
-      const de = ve(X);
-      de && R && m == null && (m = {
-        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-        op1: n.removeOp(R.getPath()),
-        op2: n.editOp(M.getPath(), de, f(X), !0)
-      });
-      let le = 0, ye = 0;
-      const q = s.advancer(B, (x, he) => O(he) ? le - x - 1 : x - le, (x, he) => {
-        O(he) && le++;
-      }), P = s.advancer(U);
-      for (const x of M) if (typeof x == "number") {
-        const he = x - ye, be = q(he);
-        ye += +Q(P(he + le), be, M, A, R);
-      } else {
-        const he = q(x);
-        Q(P(x), he, M, A, R);
+    function le(i) {
+      if (i == null) return null;
+      const d = new r.ReadCursor(i), m = new r.WriteCursor();
+      let D;
+      const O = [], I = [];
+      return function R($, p, v) {
+        const w = $.getComponent();
+        let C, N = !1;
+        if (w) {
+          w.p != null && (p.write("d", w.p), O[w.p] = $.clone()), w.r !== void 0 && p.write("i", w.r), w.d != null && (p.write("p", w.d), v = void 0), w.i !== void 0 && (v = C = w.i);
+          const g = ve(w);
+          g && (v === void 0 ? (D || (D = /* @__PURE__ */ new Set()), D.add(w)) : (f(w), v = g.apply(v, f(w)), N = !0));
+        }
+        let B = 0;
+        for (const g of $) {
+          p.descend(g);
+          const U = typeof g == "number" ? g - B : g, re = Y(v, U);
+          s($.getComponent()) && B++;
+          const te = R($, p, re);
+          if (v !== void 0 && te !== void 0) {
+            if (N || (N = !0, v = x(v)), !S(v, U)) throw Error("Cannot modify child - invalid operation");
+            v[U] = te;
+          }
+          p.ascend();
+        }
+        if (C === void 0) return N ? v : void 0;
+        p.write("r", v);
+      }(d, m, void 0), D && (m.reset(), function R($, p, v) {
+        const w = p.getComponent();
+        if (w) {
+          const g = w.d;
+          if (g != null && ($ = O[g], v = I[g] = r.writeCursor()), D.has(w)) {
+            const U = ve(w);
+            if (!U.invert) throw Error(`Cannot invert subtype ${U.name}`);
+            y(v, U, U.invert(f(w)));
+          }
+        }
+        let C = 0, N = 0;
+        const B = r.advancer($, (g, U) => _(U) ? C - g - 1 : g - C, (g, U) => {
+          _(U) && C++;
+        });
+        for (const g of p) if (typeof g == "number") {
+          const U = g - N, re = B(U), te = U + C;
+          v.descend(te), R(re, p, v), s(p.getComponent()) && N++, v.ascend();
+        } else v.descend(g), R(B(g), p, v), v.ascend();
+        B.end();
+      }(d.clone(), d, m), I.length && (m.reset(), d.traverse(m, (R, $) => {
+        const p = R.p;
+        if (p != null) {
+          const v = I[p];
+          v && v.get(), v && $.mergeTree(v.get());
+        }
+      }))), m.get();
+    }
+    const ge = (i, d) => i.some((m) => typeof m == "object" && (Array.isArray(m) ? ge(m, d) : d(m)));
+    function De(i, d) {
+      if (i == null || !ge(i, (p) => {
+        var v;
+        return p.r !== void 0 || ((v = ve(p)) === null || v === void 0 ? void 0 : v.makeInvertible) != null;
+      })) return i;
+      const m = new r.ReadCursor(i), D = new r.WriteCursor();
+      let O = !1;
+      const I = [], R = [], $ = (p, v, w) => {
+        const C = p.getComponent();
+        let N = !1;
+        if (C) {
+          C.d != null && v.write("d", C.d), C.i !== void 0 && v.write("i", C.i);
+          const g = C.p;
+          if (g != null && (I[g] = p.clone(), o(w !== void 0, "Operation picks up at an invalid key"), R[g] = w, v.write("p", C.p)), C.r !== void 0 && w === void 0) throw Error("Invalid doc / op in makeInvertible: removed item missing from doc");
+          const U = ve(C);
+          U && (U.makeInvertible ? O = !0 : y(v, U, f(C), !0));
+        }
+        let B = 0;
+        for (const g of p) {
+          v.descend(g);
+          const U = typeof g == "number" ? g - B : g, re = Y(w, U), te = $(p, v, re);
+          re !== te && (N || (N = !0, w = x(w)), te === void 0 ? (w = c(w, U), typeof g == "number" && B++) : w[U] = te), v.ascend();
+        }
+        return C && (C.r !== void 0 ? (v.write("r", t.default(w)), w = void 0) : C.p != null && (w = void 0)), w;
+      };
+      return $(m, D, d), D.get(), O && (D.reset(), function p(v, w, C, N, B) {
+        const g = w.getComponent();
+        if (g) {
+          g.i !== void 0 ? (N = g.i, B = !0) : g.d != null && (N = R[g.d], v = I[g.d], B = !1, g.d);
+          let K = ve(g);
+          if (K && K.makeInvertible) {
+            const se = f(g);
+            y(C, K, K.makeInvertible(se, N), !0);
+          }
+        }
+        let U = 0, re = 0;
+        const te = r.advancer(v, (K, se) => _(se) ? U - K - 1 : K - U, (K, se) => {
+          _(se) && U++;
+        });
+        for (const K of w) if (typeof K == "number") {
+          const se = K - re, Ne = te(se), Oe = se + U, ye = Y(N, B ? se : Oe);
+          C.descend(K), p(Ne, w, C, ye, B), s(w.getComponent()) && re++, C.ascend();
+        } else {
+          const se = Y(N, K);
+          C.descend(K), p(te(K), w, C, se, B), C.ascend();
+        }
+        te.end();
+      }(m.clone(), m, D, d, !1)), D.get();
+    }
+    function Ut(i, d) {
+      return le(De(i, d));
+    }
+    const it = (i) => {
+      if (i == null) return null;
+      const d = i.slice();
+      for (let m = 0; m < i.length; m++) {
+        const D = d[m];
+        Array.isArray(D) && (d[m] = it(D));
       }
-      return q.end(), P.end(), ee;
-    }(me, _e, _e.clone(), null, null), p.map((Q) => Q && Q.get()), m) return {
-      ok: !1,
-      conflict: m
+      return d;
     };
-    N.map((Q) => !!Q);
-    const Pe = [];
-    let Me = null;
-    (function Q(U, B, M, A, R) {
-      let X = !1;
-      const Y = a(B);
-      if (O(Y)) {
-        const q = Y.p;
-        q != null ? (M = p[q], A = re[q] = s.writeCursor(), X = !0, R = null) : (M = null, R = B.clone());
-      } else o(a(M)) && (M = null);
-      const ee = U.getComponent();
-      if (ee) {
-        const q = ee.p;
-        q != null ? (R && (T[q] = R), Pe[q] = R || D === 1 && X ? null : A.getComponent(), C[q] = U.clone(), M && (I[q] = M.clone())) : ee.r !== void 0 && (R || A.write("r", !0), (R || X) && (Me == null && (Me = /* @__PURE__ */ new Set()), Me.add(ee)));
-      }
-      let fe = 0, de = 0;
-      const le = s.advancer(B, void 0, (q, P) => {
-        O(P) && fe++;
-      }), ye = s.advancer(M, (q, P) => o(P) ? ~(q - de) : q - de, (q, P) => {
-        o(P) && de++;
-      });
-      if (U) for (const q of U) if (typeof q == "string") {
-        const P = le(q), x = ye(q);
-        A.descend(q), Q(U, P, x, A, R), A.ascend();
-      } else {
-        const P = le(q), x = q - fe, he = O(a(P)) ? null : ye(x), be = x + de;
-        l(be >= 0), A.descend(be), Q(U, P, he, A, R), A.ascend();
-      }
-      le.end(), ye.end();
-    })(me, _e, _e.clone(), oe, null), oe.reset();
-    let Le = [];
-    if (function Q(U, B, M, A, R, X) {
-      l(B);
-      const Y = B.getComponent();
-      let ee = a(A), fe = !1;
-      const de = (S, ie, Oe) => S ? n.moveOp(S.getPath(), ie.getPath()) : n.insertOp(ie.getPath(), Oe.i);
-      if (o(Y)) {
-        const S = Y.d;
-        S != null && ($[S] = B.clone());
-        const ie = S != null ? Pe[S] : null;
-        let Oe = !1;
-        if (Y.i !== void 0 || S != null && ie) {
-          let ce;
-          ee && (ee.i !== void 0 || (ce = ee.d) != null && !g[ce]) && (Oe = ce != null ? S != null && S === K[ce] : t.default(ee.i, Y.i), Oe || ce != null && D !== 1 && K[ce] != null || m == null && (m = {
-            type: d.ConflictType.DROP_COLLISION,
-            op1: de(S != null ? C[S] : null, B, Y),
-            op2: de(ce != null ? j[ce] : null, A, ee)
-          })), Oe || (X ? m == null && (m = {
-            type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-            op1: de(S != null ? C[S] : null, B, Y),
-            op2: n.removeOp(X.getPath())
-          }) : (S != null ? (Le[Te] = S, R.write("d", ie.p = Te++)) : R.write("i", i.default(Y.i)), fe = !0));
-        } else if (S != null && !ie) {
-          const ce = T[S];
-          ce && (X = ce.clone());
+    function st(i, d, m) {
+      o(m === "left" || m === "right", "Direction must be left or right");
+      const D = m === "left" ? 0 : 1;
+      if (d == null) return {
+        ok: !0,
+        result: i
+      };
+      z(i), z(d);
+      let O = null;
+      const I = [], R = [], $ = [], p = [], v = [], w = [], C = [], N = [], B = [], g = [], U = [], re = [], te = [], K = [], se = [];
+      let Ne = 0;
+      const Oe = r.readCursor(i), ye = r.readCursor(d), oe = r.writeCursor();
+      if (function Q(A, W = null, M) {
+        const P = l(W);
+        P && (P.r !== void 0 ? M = W.clone() : P.p != null && (M = null, w[P.p] = A.clone()));
+        const k = A.getComponent();
+        let X;
+        k && (X = k.p) != null && (v[X] = W ? W.clone() : null, $[X] = A.clone(), M && (g[X] = !0, B[X] = M), P && P.p != null && (K[X] = P.p));
+        const J = r.advancer(W);
+        for (const ee of A) Q(A, J(ee), M);
+        J.end();
+      }(ye, Oe, null), function Q(A, W, M, P, k) {
+        const X = M.getComponent();
+        let J, ee = !1;
+        X && ((J = X.d) != null ? (p[J] = M.clone(), P != null && (se[P] == null && (se[P] = []), se[P].push(J)), A = v[J] || null, W = $[J] || null, g[J] ? (k && (U[J] = !0), k = B[J] || null) : !k || D !== 1 && K[J] != null || O == null && (O = {
+          type: u.ConflictType.RM_UNEXPECTED_CONTENT,
+          op1: a.removeOp(k.getPath()),
+          op2: a.moveOp(W.getPath(), M.getPath())
+        }), ee = !0) : X.i !== void 0 && (A = W = null, ee = !0, k && O == null && (O = {
+          type: u.ConflictType.RM_UNEXPECTED_CONTENT,
+          op1: a.removeOp(k.getPath()),
+          op2: a.insertOp(M.getPath(), X.i)
+        })));
+        const fe = l(A);
+        fe && (fe.r !== void 0 ? k = A.clone() : fe.p != null && (fe.p, P = fe.p, k = null));
+        const de = ve(X);
+        de && k && O == null && (O = {
+          type: u.ConflictType.RM_UNEXPECTED_CONTENT,
+          op1: a.removeOp(k.getPath()),
+          op2: a.editOp(M.getPath(), de, f(X), !0)
+        });
+        let ae = 0, me = 0;
+        const H = r.advancer(W, (G, he) => _(he) ? ae - G - 1 : G - ae, (G, he) => {
+          _(he) && ae++;
+        }), T = r.advancer(A);
+        for (const G of M) if (typeof G == "number") {
+          const he = G - me, we = H(he);
+          me += +Q(T(he + ae), we, M, P, k);
+        } else {
+          const he = H(G);
+          Q(T(G), he, M, P, k);
+        }
+        return H.end(), T.end(), ee;
+      }(Oe, ye, ye.clone(), null, null), p.map((Q) => Q && Q.get()), O) return {
+        ok: !1,
+        conflict: O
+      };
+      U.map((Q) => !!Q);
+      const Pe = [];
+      let Ae = null;
+      (function Q(A, W, M, P, k) {
+        let X = !1;
+        const J = l(W);
+        if (_(J)) {
+          const H = J.p;
+          H != null ? (M = p[H], P = re[H] = r.writeCursor(), X = !0, k = null) : (M = null, k = W.clone());
+        } else s(l(M)) && (M = null);
+        const ee = A.getComponent();
+        if (ee) {
+          const H = ee.p;
+          H != null ? (k && (N[H] = k), Pe[H] = k || D === 1 && X ? null : P.getComponent(), I[H] = A.clone(), M && (C[H] = M.clone())) : ee.r !== void 0 && (k || P.write("r", !0), (k || X) && (Ae == null && (Ae = /* @__PURE__ */ new Set()), Ae.add(ee)));
         }
-        S != null ? (U = C[S], M = b[S], A = I[S]) : Y.i !== void 0 && (U = M = null, Oe || (A = null));
-      } else O(a(U)) && (U = M = A = null);
-      const le = a(U), ye = a(M);
-      if (O(ye)) {
-        const S = ye.p;
-        ye.r !== void 0 && (!le || le.r === void 0) || g[S] ? (A = null, X = M.clone()) : S != null && (A = p[S], D !== 1 && K[S] != null || ((R = te[S]) || (R = te[S] = s.writeCursor()), R.reset(), X = null));
-      } else !o(Y) && o(ee) && (A = null);
-      ee = A != null ? A.getComponent() : null;
-      const q = ve(Y);
-      if (q) {
-        const S = f(Y);
-        if (X) m == null && (m = {
-          type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-          op1: n.editOp(B.getPath(), q, S, !0),
-          op2: n.removeOp(X.getPath())
+        let fe = 0, de = 0;
+        const ae = r.advancer(W, void 0, (H, T) => {
+          _(T) && fe++;
+        }), me = r.advancer(M, (H, T) => s(T) ? ~(H - de) : H - de, (H, T) => {
+          s(T) && de++;
         });
-        else {
-          const ie = ve(ee);
-          let Oe;
-          if (ie) {
-            if (q !== ie) throw Error("Transforming incompatible types");
-            const ce = f(ee);
-            Oe = q.transform(S, ce, y);
-          } else Oe = i.default(S);
-          _(R, q, Oe);
+        if (A) for (const H of A) if (typeof H == "string") {
+          const T = ae(H), G = me(H);
+          P.descend(H), Q(A, T, G, P, k), P.ascend();
+        } else {
+          const T = ae(H), G = H - fe, he = _(l(T)) ? null : me(G), we = G + de;
+          o(we >= 0), P.descend(we), Q(A, T, he, P, k), P.ascend();
         }
-      }
-      let P = 0, x = 0, he = 0, be = 0, We = 0, He = 0, Ne = U != null && U.descendFirst(), Ye = Ne;
-      const ze = s.advancer(M, void 0, (S, ie) => {
-        O(ie) && he++;
-      });
-      let Se = A != null && A.descendFirst(), je = Se;
-      for (const S of B) if (typeof S == "number") {
-        let ie;
-        const Oe = o(B.getComponent()), ce = S - x;
-        {
-          let Be;
-          for (; Ne && typeof (Be = U.getKey()) == "number"; ) {
-            Be += P;
-            const ke = U.getComponent(), Xe = O(ke);
-            if (Be > ce || Be === ce && (!Xe || D === 0 && Oe)) break;
-            if (Xe) {
-              P--;
-              const Ke = ke.p;
-              K.includes(Ke), ke.d, a(te[ke.d]), O(a(te[ke.d])), (ke.r === void 0 || Me && Me.has(ke)) && (Ke == null || !Pe[Ke] || D !== 1 && K.includes(Ke)) || We--;
-            }
-            Ne = U.nextSibling();
+        ae.end(), me.end();
+      })(Oe, ye, ye.clone(), oe, null), oe.reset();
+      let Le = [];
+      if (function Q(A, W, M, P, k, X) {
+        o(W);
+        const J = W.getComponent();
+        let ee = l(P), fe = !1;
+        const de = (j, ie, _e) => j ? a.moveOp(j.getPath(), ie.getPath()) : a.insertOp(ie.getPath(), _e.i);
+        if (s(J)) {
+          const j = J.d;
+          j != null && (R[j] = W.clone());
+          const ie = j != null ? Pe[j] : null;
+          let _e = !1;
+          if (J.i !== void 0 || j != null && ie) {
+            let ue;
+            ee && (ee.i !== void 0 || (ue = ee.d) != null && !g[ue]) && (_e = ue != null ? j != null && j === K[ue] : n.default(ee.i, J.i), _e || ue != null && D !== 1 && K[ue] != null || O == null && (O = {
+              type: u.ConflictType.DROP_COLLISION,
+              op1: de(j != null ? I[j] : null, W, J),
+              op2: de(ue != null ? $[ue] : null, P, ee)
+            })), _e || (X ? O == null && (O = {
+              type: u.ConflictType.RM_UNEXPECTED_CONTENT,
+              op1: de(j != null ? I[j] : null, W, J),
+              op2: a.removeOp(X.getPath())
+            }) : (j != null ? (Le[Ne] = j, k.write("d", ie.p = Ne++)) : k.write("i", t.default(J.i)), fe = !0));
+          } else if (j != null && !ie) {
+            const ue = N[j];
+            ue && (X = ue.clone());
+          }
+          j != null ? (A = I[j], M = w[j], P = C[j]) : J.i !== void 0 && (A = M = null, _e || (P = null));
+        } else _(l(A)) && (A = M = P = null);
+        const ae = l(A), me = l(M);
+        if (_(me)) {
+          const j = me.p;
+          me.r !== void 0 && (!ae || ae.r === void 0) || g[j] ? (P = null, X = M.clone()) : j != null && (P = p[j], D !== 1 && K[j] != null || ((k = te[j]) || (k = te[j] = r.writeCursor()), k.reset(), X = null));
+        } else !s(J) && s(ee) && (P = null);
+        ee = P != null ? P.getComponent() : null;
+        const H = ve(J);
+        if (H) {
+          const j = f(J);
+          if (X) O == null && (O = {
+            type: u.ConflictType.RM_UNEXPECTED_CONTENT,
+            op1: a.editOp(W.getPath(), H, j, !0),
+            op2: a.removeOp(X.getPath())
+          });
+          else {
+            const ie = ve(ee);
+            let _e;
+            if (ie) {
+              if (H !== ie) throw Error("Transforming incompatible types");
+              const ue = f(ee);
+              _e = H.transform(j, ue, m);
+            } else _e = t.default(j);
+            y(k, H, _e);
           }
-          ie = Ne && Be === ce ? U : null;
         }
-        const Re = ce - P;
-        let Ge = ze(Re);
-        const rt = Re - he;
-        let Je = null;
-        {
-          let Be, ke;
-          for (; Se && typeof (Be = A.getKey()) == "number"; ) {
-            ke = Be - be;
-            const Xe = A.getComponent(), Ke = o(Xe);
-            if (ke > rt) break;
-            if (ke === rt) {
-              if (!Ke) {
-                Je = A;
-                break;
+        let T = 0, G = 0, he = 0, we = 0, xe = 0, qe = 0, Me = A != null && A.descendFirst(), Ye = Me;
+        const Xe = r.advancer(M, void 0, (j, ie) => {
+          _(ie) && he++;
+        });
+        let je = P != null && P.descendFirst(), $e = je;
+        for (const j of W) if (typeof j == "number") {
+          let ie;
+          const _e = s(W.getComponent()), ue = j - G;
+          {
+            let We;
+            for (; Me && typeof (We = A.getKey()) == "number"; ) {
+              We += T;
+              const ke = A.getComponent(), Je = _(ke);
+              if (We > ue || We === ue && (!Je || D === 0 && _e)) break;
+              if (Je) {
+                T--;
+                const Ke = ke.p;
+                K.includes(Ke), ke.d, l(te[ke.d]), _(l(te[ke.d])), (ke.r === void 0 || Ae && Ae.has(ke)) && (Ke == null || !Pe[Ke] || D !== 1 && K.includes(Ke)) || xe--;
               }
-              {
-                if (D === 0 && Oe) {
-                  Je = A;
+              Me = A.nextSibling();
+            }
+            ie = Me && We === ue ? A : null;
+          }
+          const Ue = ue - T;
+          let Be = Xe(Ue);
+          const ot = Ue - he;
+          let Qe = null;
+          {
+            let We, ke;
+            for (; je && typeof (We = P.getKey()) == "number"; ) {
+              ke = We - we;
+              const Je = P.getComponent(), Ke = s(Je);
+              if (ke > ot) break;
+              if (ke === ot) {
+                if (!Ke) {
+                  Qe = P;
                   break;
                 }
-                const Ve = Ge && O(Ge.getComponent());
-                if (D === 0 && Ve) break;
+                {
+                  if (D === 0 && _e) {
+                    Qe = P;
+                    break;
+                  }
+                  const Fe = Be && _(Be.getComponent());
+                  if (D === 0 && Fe) break;
+                }
               }
+              if (Ke) {
+                const Fe = Je.d;
+                K[Fe], Je.i === void 0 && (g[Fe] || K[Fe] != null && D !== 1) ? (g[Fe] || K[Fe] != null && D === 0) && (we++, qe--) : we++;
+              }
+              je = P.nextSibling();
             }
-            if (Ke) {
-              const Ve = Xe.d;
-              K[Ve], Xe.i === void 0 && (g[Ve] || K[Ve] != null && D !== 1) ? (g[Ve] || K[Ve] != null && D === 0) && (be++, He--) : be++;
-            }
-            Se = A.nextSibling();
-          }
-        }
-        const Ot = rt + be + We + He;
-        l(Ot >= 0, "trying to descend to a negative index"), R.descend(Ot), Oe && (ie = Ge = Je = null, x++), Q(ie, B, Ge, Je, R, X) && He++, R.ascend();
-      } else {
-        let ie;
-        for (; Ne && (ie = U.getKey(), typeof ie != "string" || !(ie > S || ie === S)); ) Ne = U.nextSibling();
-        const Oe = Ne && ie === S ? U : null, ce = ze(S);
-        let Re;
-        for (; Se && (Re = A.getKey(), typeof Re != "string" || !(Re > S || Re === S)); ) Se = A.nextSibling();
-        const Ge = Se && Re === S ? A : null;
-        R.descend(S), Q(Oe, B, ce, Ge, R, X), R.ascend();
-      }
-      return ze.end(), Ye && U.ascend(), je && A.ascend(), fe;
-    }(me, me.clone(), _e, _e.clone(), oe, null), m) return {
-      ok: !1,
-      conflict: m
-    };
-    oe.reset();
-    const Ue = (Q, U, B) => Q.traverse(U, (M, A) => {
-      M.d != null && B(M.d, Q, A);
-    });
-    (g.length || re.length) && (Ue(_e, oe, (Q, U, B) => {
-      g[Q] && !N[Q] && B.write("r", !0), re[Q] && B.mergeTree(re[Q].get());
-    }), oe.reset());
-    const Ee = [], $e = [];
-    if ((te.length || g.length) && !m) {
-      const Q = s.readCursor(tt(oe.get()));
-      if (Ue(Q, null, (U, B) => {
-        Ee[U] = B.clone();
-      }), te.forEach((U) => {
-        U && Ue(s.readCursor(U.get()), null, (B, M) => {
-          Ee[B] = M.clone();
-        });
-      }), function U(B, M, A, R, X, Y) {
-        const ee = a(M);
-        if (ee && O(ee)) if (ee.p != null) {
-          const P = ee.p;
-          Ee[P].getPath(), A = Ee[P], R = $e[P] = s.writeCursor();
-        } else ee.r !== void 0 && (A = null);
-        else o(a(A)) && (A = null);
-        const fe = B.getComponent();
-        if (fe) {
-          let P;
-          if ((P = fe.d) != null) {
-            const x = te[P];
-            x && (x.get(), R.mergeTree(x.get()), A = s.readCursor(x.get()));
           }
+          const yt = ot + we + xe + qe;
+          o(yt >= 0, "trying to descend to a negative index"), k.descend(yt), _e && (ie = Be = Qe = null, G++), Q(ie, W, Be, Qe, k, X) && qe++, k.ascend();
+        } else {
+          let ie;
+          for (; Me && (ie = A.getKey(), typeof ie != "string" || !(ie > j || ie === j)); ) Me = A.nextSibling();
+          const _e = Me && ie === j ? A : null, ue = Xe(j);
+          let Ue;
+          for (; je && (Ue = P.getKey(), typeof Ue != "string" || !(Ue > j || Ue === j)); ) je = P.nextSibling();
+          const Be = je && Ue === j ? P : null;
+          k.descend(j), Q(_e, W, ue, Be, k, X), k.ascend();
         }
-        let de = 0, le = 0;
-        const ye = s.advancer(M, void 0, (P, x) => {
-          O(x) && de--;
-        }), q = s.advancer(A, (P, x) => o(x) ? -(P - le) - 1 : P - le, (P, x) => {
-          o(x) && le++;
-        });
-        for (const P of B) if (typeof P == "number") {
-          const x = ye(P), he = P + de, be = q(he), We = he + le;
-          R.descend(We), U(B, x, be, R), R.ascend();
-        } else R.descend(P), U(B, ye(P), q(P), R), R.ascend();
-        ye.end(), q.end();
-      }(_e, Q, Q.clone(), oe), oe.reset(), m) return {
+        return Xe.end(), Ye && A.ascend(), $e && P.ascend(), fe;
+      }(Oe, Oe.clone(), ye, ye.clone(), oe, null), O) return {
         ok: !1,
-        conflict: m
+        conflict: O
       };
-      if (oe.get(), $e.length) {
-        const U = $e.map((M) => M ? M.get() : null), B = s.readCursor(tt(oe.get()));
-        if (Ue(B, oe, (M, A, R) => {
-          const X = U[M];
-          X && (R.mergeTree(X), U[M] = null);
-        }), U.find((M) => M)) {
-          const M = s.writeCursor(), A = s.writeCursor();
-          let R = 0, X = 0;
-          U.forEach((Y) => {
-            Y != null && Ue(s.readCursor(Y), null, (ee) => {
-              const fe = Le[ee];
-              M.writeMove(C[fe].getPath(), $[fe].getPath(), R++);
-              const de = se[fe];
-              de && de.forEach((le) => {
-                g[le] || D !== 1 && K[le] != null || A.writeMove(j[le].getPath(), p[le].getPath(), X++);
+      oe.reset();
+      const Te = (Q, A, W) => Q.traverse(A, (M, P) => {
+        M.d != null && W(M.d, Q, P);
+      });
+      (g.length || re.length) && (Te(ye, oe, (Q, A, W) => {
+        g[Q] && !U[Q] && W.write("r", !0), re[Q] && W.mergeTree(re[Q].get());
+      }), oe.reset());
+      const Ie = [], Re = [];
+      if ((te.length || g.length) && !O) {
+        const Q = r.readCursor(it(oe.get()));
+        if (Te(Q, null, (A, W) => {
+          Ie[A] = W.clone();
+        }), te.forEach((A) => {
+          A && Te(r.readCursor(A.get()), null, (W, M) => {
+            Ie[W] = M.clone();
+          });
+        }), function A(W, M, P, k, X, J) {
+          const ee = l(M);
+          if (ee && _(ee)) if (ee.p != null) {
+            const T = ee.p;
+            Ie[T].getPath(), P = Ie[T], k = Re[T] = r.writeCursor();
+          } else ee.r !== void 0 && (P = null);
+          else s(l(P)) && (P = null);
+          const fe = W.getComponent();
+          if (fe) {
+            let T;
+            if ((T = fe.d) != null) {
+              const G = te[T];
+              G && (G.get(), k.mergeTree(G.get()), P = r.readCursor(G.get()));
+            }
+          }
+          let de = 0, ae = 0;
+          const me = r.advancer(M, void 0, (T, G) => {
+            _(G) && de--;
+          }), H = r.advancer(P, (T, G) => s(G) ? -(T - ae) - 1 : T - ae, (T, G) => {
+            s(G) && ae++;
+          });
+          for (const T of W) if (typeof T == "number") {
+            const G = me(T), he = T + de, we = H(he), xe = he + ae;
+            k.descend(xe), A(W, G, we, k), k.ascend();
+          } else k.descend(T), A(W, me(T), H(T), k), k.ascend();
+          me.end(), H.end();
+        }(ye, Q, Q.clone(), oe), oe.reset(), O) return {
+          ok: !1,
+          conflict: O
+        };
+        if (oe.get(), Re.length) {
+          const A = Re.map((M) => M ? M.get() : null), W = r.readCursor(it(oe.get()));
+          if (Te(W, oe, (M, P, k) => {
+            const X = A[M];
+            X && (k.mergeTree(X), A[M] = null);
+          }), A.find((M) => M)) {
+            const M = r.writeCursor(), P = r.writeCursor();
+            let k = 0, X = 0;
+            A.forEach((J) => {
+              J != null && Te(r.readCursor(J), null, (ee) => {
+                const fe = Le[ee];
+                M.writeMove(I[fe].getPath(), R[fe].getPath(), k++);
+                const de = se[fe];
+                de && de.forEach((ae) => {
+                  g[ae] || D !== 1 && K[ae] != null || P.writeMove($[ae].getPath(), p[ae].getPath(), X++);
+                });
               });
-            });
-          }), m = {
-            type: d.ConflictType.BLACKHOLE,
-            op1: M.get(),
-            op2: A.get()
-          };
+            }), O = {
+              type: u.ConflictType.BLACKHOLE,
+              op1: M.get(),
+              op2: P.get()
+            };
+          }
         }
       }
+      return O ? {
+        ok: !1,
+        conflict: O
+      } : {
+        ok: !0,
+        result: oe.get()
+      };
     }
-    return m ? {
-      ok: !1,
-      conflict: m
-    } : {
-      ok: !0,
-      result: oe.get()
+    const pt = (i) => {
+      const d = new Error("Transform detected write conflict");
+      throw d.conflict = i, d.type = d.name = "writeConflict", d;
     };
-  }
-  const gt = (r) => {
-    const u = new Error("Transform detected write conflict");
-    throw u.conflict = r, u.type = u.name = "writeConflict", u;
-  };
-  function At(r, u, y) {
-    const D = nt(r, u, y);
-    if (D.ok) return D.result;
-    gt(D.conflict);
-  }
-  const qe = (r) => {
-    const u = s.writeCursor();
-    return s.readCursor(r).traverse(u, (y, D) => {
-      (o(y) || ve(y)) && D.write("r", !0);
-    }), u.get();
-  }, Pt = (r, u) => {
-    const { type: y, op1: D, op2: m } = r;
-    switch (y) {
-      case d.ConflictType.DROP_COLLISION:
-        return u === "left" ? [null, qe(m)] : [qe(D), null];
-      case d.ConflictType.RM_UNEXPECTED_CONTENT:
-        let C = !1;
-        return s.readCursor(D).traverse(null, ($) => {
-          $.r !== void 0 && (C = !0);
-        }), C ? [null, qe(m)] : [qe(D), null];
-      case d.ConflictType.BLACKHOLE:
-        return [qe(D), qe(m)];
-      default:
-        throw Error("Unrecognised conflict: " + y);
+    function kt(i, d, m) {
+      const D = st(i, d, m);
+      if (D.ok) return D.result;
+      pt(D.conflict);
     }
-  };
-  function _t(r, u, y, D) {
-    let m = null;
-    for (; ; ) {
-      const C = nt(u, y, D);
-      if (C.ok) return ne(m, C.result);
-      {
-        const { conflict: $ } = C;
-        r($) || gt($);
-        const [j, p] = Pt($, D);
-        u = ne(H(u), j), y = ne(H(y), p), m = ne(m, p);
+    const ze = (i) => {
+      const d = r.writeCursor();
+      return r.readCursor(i).traverse(d, (m, D) => {
+        (s(m) || ve(m)) && D.write("r", !0);
+      }), d.get();
+    }, St = (i, d) => {
+      const { type: m, op1: D, op2: O } = i;
+      switch (m) {
+        case u.ConflictType.DROP_COLLISION:
+          return d === "left" ? [null, ze(O)] : [ze(D), null];
+        case u.ConflictType.RM_UNEXPECTED_CONTENT:
+          let I = !1;
+          return r.readCursor(D).traverse(null, (R) => {
+            R.r !== void 0 && (I = !0);
+          }), I ? [null, ze(O)] : [ze(D), null];
+        case u.ConflictType.BLACKHOLE:
+          return [ze(D), ze(O)];
+        default:
+          throw Error("Unrecognised conflict: " + m);
+      }
+    };
+    function gt(i, d, m, D) {
+      let O = null;
+      for (; ; ) {
+        const I = st(d, m, D);
+        if (I.ok) return ne(O, I.result);
+        {
+          const { conflict: R } = I;
+          i(R) || pt(R);
+          const [$, p] = St(R, D);
+          d = ne(q(d), $), m = ne(q(m), p), O = ne(O, p);
+        }
       }
     }
-  }
-})(Et);
-(function(n) {
-  var e = Ce && Ce.__createBinding || (Object.create ? function(d, l, a, E) {
-    E === void 0 && (E = a), Object.defineProperty(d, E, { enumerable: !0, get: function() {
-      return l[a];
+  }(Ze)), Ze;
+}
+var Dt;
+function Qt() {
+  return Dt || (Dt = 1, function(a) {
+    var e = Ve && Ve.__createBinding || (Object.create ? function(u, o, l, E) {
+      E === void 0 && (E = l), Object.defineProperty(u, E, { enumerable: !0, get: function() {
+        return o[l];
+      } });
+    } : function(u, o, l, E) {
+      E === void 0 && (E = l), u[E] = o[l];
+    }), n = Ve && Ve.__exportStar || function(u, o) {
+      for (var l in u) l !== "default" && !o.hasOwnProperty(l) && e(o, u, l);
+    };
+    Object.defineProperty(a, "__esModule", { value: !0 }), n(Zt(), a);
+    var t = At();
+    Object.defineProperty(a, "ReadCursor", { enumerable: !0, get: function() {
+      return t.ReadCursor;
+    } }), Object.defineProperty(a, "WriteCursor", { enumerable: !0, get: function() {
+      return t.WriteCursor;
     } });
-  } : function(d, l, a, E) {
-    E === void 0 && (E = a), d[E] = l[a];
-  }), t = Ce && Ce.__exportStar || function(d, l) {
-    for (var a in d) a !== "default" && !l.hasOwnProperty(a) && e(l, d, a);
-  };
-  Object.defineProperty(n, "__esModule", { value: !0 }), t(Et, n);
-  var i = ft;
-  Object.defineProperty(n, "ReadCursor", { enumerable: !0, get: function() {
-    return i.ReadCursor;
-  } }), Object.defineProperty(n, "WriteCursor", { enumerable: !0, get: function() {
-    return i.WriteCursor;
-  } });
-  var s = ht;
-  Object.defineProperty(n, "ConflictType", { enumerable: !0, get: function() {
-    return s.ConflictType;
-  } });
-})(F);
-class Vt {
+    var r = Mt();
+    Object.defineProperty(a, "ConflictType", { enumerable: !0, get: function() {
+      return r.ConflictType;
+    } });
+  }(Ve)), Ve;
+}
+var V = Qt();
+class en {
   constructor() {
-    V(this, "drawingManagerData", {});
-    V(this, "_oldDrawingManagerData", {});
-    V(this, "_focusDrawings", []);
-    V(this, "_remove$", new we());
-    V(this, "remove$", this._remove$.asObservable());
-    V(this, "_add$", new we());
-    V(this, "add$", this._add$.asObservable());
-    V(this, "_update$", new we());
-    V(this, "update$", this._update$.asObservable());
-    V(this, "_order$", new we());
-    V(this, "order$", this._order$.asObservable());
-    V(this, "_group$", new we());
-    V(this, "group$", this._group$.asObservable());
-    V(this, "_ungroup$", new we());
-    V(this, "ungroup$", this._ungroup$.asObservable());
-    V(this, "_refreshTransform$", new we());
-    V(this, "refreshTransform$", this._refreshTransform$.asObservable());
-    V(this, "_visible$", new we());
-    V(this, "visible$", this._visible$.asObservable());
+    F(this, "drawingManagerData", {});
+    F(this, "_oldDrawingManagerData", {});
+    F(this, "_focusDrawings", []);
+    F(this, "_remove$", new be());
+    F(this, "remove$", this._remove$.asObservable());
+    F(this, "_add$", new be());
+    F(this, "add$", this._add$.asObservable());
+    F(this, "_update$", new be());
+    F(this, "update$", this._update$.asObservable());
+    F(this, "_order$", new be());
+    F(this, "order$", this._order$.asObservable());
+    F(this, "_group$", new be());
+    F(this, "group$", this._group$.asObservable());
+    F(this, "_ungroup$", new be());
+    F(this, "ungroup$", this._ungroup$.asObservable());
+    F(this, "_refreshTransform$", new be());
+    F(this, "refreshTransform$", this._refreshTransform$.asObservable());
+    F(this, "_visible$", new be());
+    F(this, "visible$", this._visible$.asObservable());
     // private readonly _externalUpdate$ = new Subject<T[]>();
     // readonly externalUpdate$ = this._externalUpdate$.asObservable();
-    V(this, "_focus$", new we());
-    V(this, "focus$", this._focus$.asObservable());
-    V(this, "_featurePluginUpdate$", new we());
-    V(this, "featurePluginUpdate$", this._featurePluginUpdate$.asObservable());
-    V(this, "_featurePluginAdd$", new we());
-    V(this, "featurePluginAdd$", this._featurePluginAdd$.asObservable());
-    V(this, "_featurePluginRemove$", new we());
-    V(this, "featurePluginRemove$", this._featurePluginRemove$.asObservable());
-    V(this, "_featurePluginOrderUpdate$", new we());
-    V(this, "featurePluginOrderUpdate$", this._featurePluginOrderUpdate$.asObservable());
-    V(this, "_featurePluginGroupUpdate$", new we());
-    V(this, "featurePluginGroupUpdate$", this._featurePluginGroupUpdate$.asObservable());
-    V(this, "_featurePluginUngroupUpdate$", new we());
-    V(this, "featurePluginUngroupUpdate$", this._featurePluginUngroupUpdate$.asObservable());
-    V(this, "_visible", !0);
-    V(this, "_editable", !0);
+    F(this, "_focus$", new be());
+    F(this, "focus$", this._focus$.asObservable());
+    F(this, "_featurePluginUpdate$", new be());
+    F(this, "featurePluginUpdate$", this._featurePluginUpdate$.asObservable());
+    F(this, "_featurePluginAdd$", new be());
+    F(this, "featurePluginAdd$", this._featurePluginAdd$.asObservable());
+    F(this, "_featurePluginRemove$", new be());
+    F(this, "featurePluginRemove$", this._featurePluginRemove$.asObservable());
+    F(this, "_featurePluginOrderUpdate$", new be());
+    F(this, "featurePluginOrderUpdate$", this._featurePluginOrderUpdate$.asObservable());
+    F(this, "_featurePluginGroupUpdate$", new be());
+    F(this, "featurePluginGroupUpdate$", this._featurePluginGroupUpdate$.asObservable());
+    F(this, "_featurePluginUngroupUpdate$", new be());
+    F(this, "featurePluginUngroupUpdate$", this._featurePluginUngroupUpdate$.asObservable());
+    F(this, "_visible", !0);
+    F(this, "_editable", !0);
   }
   dispose() {
     this._remove$.complete(), this._add$.complete(), this._update$.complete(), this._order$.complete(), this._focus$.complete(), this._featurePluginUpdate$.complete(), this._featurePluginAdd$.complete(), this._featurePluginRemove$.complete(), this._featurePluginOrderUpdate$.complete(), this.drawingManagerData = {}, this._oldDrawingManagerData = {};
@@ -1508,74 +1528,74 @@ class Vt {
     this._visible$.next(e);
   }
   refreshTransform(e) {
-    e.forEach((t) => {
-      const i = this._getCurrentBySearch(t);
-      i != null && (i.transform = t.transform, i.transforms = t.transforms, i.isMultiTransform = t.isMultiTransform);
+    e.forEach((n) => {
+      const t = this._getCurrentBySearch(n);
+      t != null && (t.transform = n.transform, t.transforms = n.transforms, t.isMultiTransform = n.isMultiTransform);
     }), this.refreshTransformNotification(e);
   }
   getDrawingDataForUnit(e) {
     return this.drawingManagerData[e] || {};
   }
   removeDrawingDataForUnit(e) {
-    const t = this.drawingManagerData[e];
-    if (t == null)
+    const n = this.drawingManagerData[e];
+    if (n == null)
       return;
     delete this.drawingManagerData[e];
-    const i = [];
-    Object.keys(t).forEach((s) => {
-      const d = t[s];
-      (d == null ? void 0 : d.data) != null && Object.keys(d.data).forEach((l) => {
-        i.push({ unitId: e, subUnitId: s, drawingId: l });
+    const t = [];
+    Object.keys(n).forEach((r) => {
+      const u = n[r];
+      (u == null ? void 0 : u.data) != null && Object.keys(u.data).forEach((o) => {
+        t.push({ unitId: e, subUnitId: r, drawingId: o });
       });
-    }), i.length > 0 && this.removeNotification(i);
+    }), t.length > 0 && this.removeNotification(t);
   }
-  registerDrawingData(e, t) {
-    this.drawingManagerData[e] = t;
+  registerDrawingData(e, n) {
+    this.drawingManagerData[e] = n;
   }
   initializeNotification(e) {
-    const t = [], i = this.drawingManagerData[e];
-    i != null && (Object.keys(i).forEach((s) => {
-      this._establishDrawingMap(e, s);
-      const d = i[s];
-      Object.keys(d.data).forEach((l) => {
-        const a = d.data[l];
-        a.unitId = e, a.subUnitId = s, t.push(a);
+    const n = [], t = this.drawingManagerData[e];
+    t != null && (Object.keys(t).forEach((r) => {
+      this._establishDrawingMap(e, r);
+      const u = t[r];
+      Object.keys(u.data).forEach((o) => {
+        const l = u.data[o];
+        l.unitId = e, l.subUnitId = r, n.push(l);
       });
-    }), t.length > 0 && this.addNotification(t));
+    }), n.length > 0 && this.addNotification(n));
   }
-  getDrawingData(e, t) {
-    return this._getDrawingData(e, t);
+  getDrawingData(e, n) {
+    return this._getDrawingData(e, n);
   }
   // Use in doc only.
-  setDrawingData(e, t, i) {
-    this.drawingManagerData[e][t].data = i;
+  setDrawingData(e, n, t) {
+    this.drawingManagerData[e][n].data = t;
   }
   getBatchAddOp(e) {
-    const t = [], i = [], s = [];
-    e.forEach((W) => {
-      const { op: O, invertOp: o } = this._addByParam(W);
-      t.push({ unitId: W.unitId, subUnitId: W.subUnitId, drawingId: W.drawingId }), i.push(O), s.push(o);
+    const n = [], t = [], r = [];
+    e.forEach((x) => {
+      const { op: _, invertOp: s } = this._addByParam(x);
+      n.push({ unitId: x.unitId, subUnitId: x.subUnitId, drawingId: x.drawingId }), t.push(_), r.push(s);
     });
-    const d = i.reduce(F.type.compose, null), l = s.reduce(F.type.compose, null), { unitId: a, subUnitId: E } = e[0];
-    return { undo: l, redo: d, unitId: a, subUnitId: E, objects: t };
+    const u = t.reduce(V.type.compose, null), o = r.reduce(V.type.compose, null), { unitId: l, subUnitId: E } = e[0];
+    return { undo: o, redo: u, unitId: l, subUnitId: E, objects: n };
   }
   getBatchRemoveOp(e) {
-    const t = [], i = [];
+    const n = [], t = [];
     e.forEach((E) => {
-      const { op: W, invertOp: O } = this._removeByParam(E);
-      t.unshift(W), i.push(O);
+      const { op: x, invertOp: _ } = this._removeByParam(E);
+      n.unshift(x), t.push(_);
     });
-    const s = t.reduce(F.type.compose, null), d = i.reduce(F.type.compose, null), { unitId: l, subUnitId: a } = e[0];
-    return { undo: d, redo: s, unitId: l, subUnitId: a, objects: e };
+    const r = n.reduce(V.type.compose, null), u = t.reduce(V.type.compose, null), { unitId: o, subUnitId: l } = e[0];
+    return { undo: u, redo: r, unitId: o, subUnitId: l, objects: e };
   }
   getBatchUpdateOp(e) {
-    const t = [], i = [], s = [];
-    e.forEach((W) => {
-      const { op: O, invertOp: o } = this._updateByParam(W);
-      t.push({ unitId: W.unitId, subUnitId: W.subUnitId, drawingId: W.drawingId }), i.push(O), s.push(o);
+    const n = [], t = [], r = [];
+    e.forEach((x) => {
+      const { op: _, invertOp: s } = this._updateByParam(x);
+      n.push({ unitId: x.unitId, subUnitId: x.subUnitId, drawingId: x.drawingId }), t.push(_), r.push(s);
     });
-    const d = i.reduce(F.type.compose, null), l = s.reduce(F.type.compose, null), { unitId: a, subUnitId: E } = e[0];
-    return { undo: l, redo: d, unitId: a, subUnitId: E, objects: t };
+    const u = t.reduce(V.type.compose, null), o = r.reduce(V.type.compose, null), { unitId: l, subUnitId: E } = e[0];
+    return { undo: o, redo: u, unitId: l, subUnitId: E, objects: n };
   }
   removeNotification(e) {
     this._remove$.next(e);
@@ -1599,61 +1619,61 @@ class Vt {
     this._refreshTransform$.next(e);
   }
   getGroupDrawingOp(e) {
-    const t = [], { unitId: i, subUnitId: s } = e[0].parent;
-    e.forEach((a) => {
-      t.push(this._getGroupDrawingOp(a));
+    const n = [], { unitId: t, subUnitId: r } = e[0].parent;
+    e.forEach((l) => {
+      n.push(this._getGroupDrawingOp(l));
     });
-    const d = t.reduce(F.type.compose, null);
-    return { undo: F.type.invertWithDoc(d, this.drawingManagerData), redo: d, unitId: i, subUnitId: s, objects: e };
+    const u = n.reduce(V.type.compose, null);
+    return { undo: V.type.invertWithDoc(u, this.drawingManagerData), redo: u, unitId: t, subUnitId: r, objects: e };
   }
   getUngroupDrawingOp(e) {
-    const t = [], { unitId: i, subUnitId: s } = e[0].parent;
-    e.forEach((a) => {
-      t.push(this._getUngroupDrawingOp(a));
+    const n = [], { unitId: t, subUnitId: r } = e[0].parent;
+    e.forEach((l) => {
+      n.push(this._getUngroupDrawingOp(l));
     });
-    const d = t.reduce(F.type.compose, null);
-    return { undo: F.type.invertWithDoc(d, this.drawingManagerData), redo: d, unitId: i, subUnitId: s, objects: e };
+    const u = n.reduce(V.type.compose, null);
+    return { undo: V.type.invertWithDoc(u, this.drawingManagerData), redo: u, unitId: t, subUnitId: r, objects: e };
   }
   getDrawingsByGroup(e) {
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    if (this.getDrawingByParam({ unitId: t, subUnitId: i, drawingId: s }) == null)
+    const { unitId: n, subUnitId: t, drawingId: r } = e;
+    if (this.getDrawingByParam({ unitId: n, subUnitId: t, drawingId: r }) == null)
       return [];
-    const l = this._getDrawingData(t, i), a = [];
-    return Object.keys(l).forEach((E) => {
-      const W = l[E];
-      W.groupId === s && a.push(W);
-    }), a;
+    const o = this._getDrawingData(n, t), l = [];
+    return Object.keys(o).forEach((E) => {
+      const x = o[E];
+      x.groupId === r && l.push(x);
+    }), l;
   }
   _getGroupDrawingOp(e) {
-    const { parent: t, children: i } = e, { unitId: s, subUnitId: d, drawingId: l } = t, a = [];
-    a.push(
-      F.insertOp([s, d, "data", l], t)
+    const { parent: n, children: t } = e, { unitId: r, subUnitId: u, drawingId: o } = n, l = [];
+    l.push(
+      V.insertOp([r, u, "data", o], n)
     );
     let E = Number.NEGATIVE_INFINITY;
-    return i.forEach((W) => {
-      const { unitId: O, subUnitId: o, drawingId: c } = W, h = this._hasDrawingOrder({ unitId: O, subUnitId: o, drawingId: c });
-      E = Math.max(E, h), a.push(
-        ...this._getUpdateParamCompareOp(W, this.getDrawingByParam({ unitId: O, subUnitId: o, drawingId: c }))
+    return t.forEach((x) => {
+      const { unitId: _, subUnitId: s, drawingId: c } = x, h = this._hasDrawingOrder({ unitId: _, subUnitId: s, drawingId: c });
+      E = Math.max(E, h), l.push(
+        ...this._getUpdateParamCompareOp(x, this.getDrawingByParam({ unitId: _, subUnitId: s, drawingId: c }))
       );
-    }), E === Number.NEGATIVE_INFINITY && (E = this._getDrawingOrder(s, d).length), a.push(
-      F.insertOp([s, d, "order", E], l)
-    ), a.reduce(F.type.compose, null);
+    }), E === Number.NEGATIVE_INFINITY && (E = this._getDrawingOrder(r, u).length), l.push(
+      V.insertOp([r, u, "order", E], o)
+    ), l.reduce(V.type.compose, null);
   }
   _getUngroupDrawingOp(e) {
-    const { parent: t, children: i } = e, { unitId: s, subUnitId: d, drawingId: l } = t, a = [];
-    return i.forEach((E) => {
-      const { unitId: W, subUnitId: O, drawingId: o } = E;
-      a.push(
-        ...this._getUpdateParamCompareOp(E, this.getDrawingByParam({ unitId: W, subUnitId: O, drawingId: o }))
+    const { parent: n, children: t } = e, { unitId: r, subUnitId: u, drawingId: o } = n, l = [];
+    return t.forEach((E) => {
+      const { unitId: x, subUnitId: _, drawingId: s } = E;
+      l.push(
+        ...this._getUpdateParamCompareOp(E, this.getDrawingByParam({ unitId: x, subUnitId: _, drawingId: s }))
       );
-    }), a.push(
-      F.removeOp([s, d, "data", l], !0)
-    ), a.push(
-      F.removeOp([s, d, "order", this._getDrawingOrder(s, d).indexOf(l)], !0)
-    ), a.reduce(F.type.compose, null);
+    }), l.push(
+      V.removeOp([r, u, "data", o], !0)
+    ), l.push(
+      V.removeOp([r, u, "order", this._getDrawingOrder(r, u).indexOf(o)], !0)
+    ), l.reduce(V.type.compose, null);
   }
-  applyJson1(e, t, i) {
-    this._establishDrawingMap(e, t), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = F.type.apply(this.drawingManagerData, i);
+  applyJson1(e, n, t) {
+    this._establishDrawingMap(e, n), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = V.type.apply(this.drawingManagerData, t);
   }
   // private _fillMissingFields(jsonOp: JSONOp) {
   //     if (jsonOp == null) {
@@ -1700,138 +1720,138 @@ class Vt {
     return this._getOldBySearch(e);
   }
   getDrawingOKey(e) {
-    const [t, i, s] = e.split("#-#");
-    return this._getCurrentBySearch({ unitId: t, subUnitId: i, drawingId: s });
+    const [n, t, r] = e.split("#-#");
+    return this._getCurrentBySearch({ unitId: n, subUnitId: t, drawingId: r });
   }
   focusDrawing(e) {
     if (e == null) {
       this._focusDrawings = [], this._focus$.next([]);
       return;
     }
-    const t = [];
-    e.forEach((i) => {
+    const n = [];
+    e.forEach((t) => {
       var E;
-      const { unitId: s, subUnitId: d, drawingId: l } = i, a = (E = this._getDrawingData(s, d)) == null ? void 0 : E[l];
-      a != null && t.push(a);
-    }), t.length > 0 && (this._focusDrawings = t, this._focus$.next(t));
+      const { unitId: r, subUnitId: u, drawingId: o } = t, l = (E = this._getDrawingData(r, u)) == null ? void 0 : E[o];
+      l != null && n.push(l);
+    }), n.length > 0 && (this._focusDrawings = n, this._focus$.next(n));
   }
   getFocusDrawings() {
     const e = [];
-    return this._focusDrawings.forEach((t) => {
-      var a;
-      const { unitId: i, subUnitId: s, drawingId: d } = t, l = (a = this._getDrawingData(i, s)) == null ? void 0 : a[d];
-      l != null && e.push(l);
+    return this._focusDrawings.forEach((n) => {
+      var l;
+      const { unitId: t, subUnitId: r, drawingId: u } = n, o = (l = this._getDrawingData(t, r)) == null ? void 0 : l[u];
+      o != null && e.push(o);
     }), e;
   }
-  getDrawingOrder(e, t) {
-    return this._getDrawingOrder(e, t);
+  getDrawingOrder(e, n) {
+    return this._getDrawingOrder(e, n);
   }
   // Use in doc only.
-  setDrawingOrder(e, t, i) {
-    this.drawingManagerData[e][t].order = i;
+  setDrawingOrder(e, n, t) {
+    this.drawingManagerData[e][n].order = t;
   }
   orderUpdateNotification(e) {
     this._order$.next(e);
   }
   getForwardDrawingsOp(e) {
-    const { unitId: t, subUnitId: i, drawingIds: s } = e, d = [], l = this.getDrawingOrder(t, i), a = [...s];
-    s.forEach((O) => {
-      const o = this._hasDrawingOrder({ unitId: t, subUnitId: i, drawingId: O });
-      if (o === -1 || o === l.length - 1)
+    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = [], o = this.getDrawingOrder(n, t), l = [...r];
+    r.forEach((_) => {
+      const s = this._hasDrawingOrder({ unitId: n, subUnitId: t, drawingId: _ });
+      if (s === -1 || s === o.length - 1)
         return;
-      const c = F.moveOp([t, i, "order", o], [t, i, "order", o + 1]);
-      d.push(c), a.includes(l[o + 1]) || a.push(l[o + 1]);
+      const c = V.moveOp([n, t, "order", s], [n, t, "order", s + 1]);
+      u.push(c), l.includes(o[s + 1]) || l.push(o[s + 1]);
     });
-    const E = d.reduce(F.type.compose, null);
-    return { undo: F.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: t, subUnitId: i, objects: { ...e, drawingIds: a } };
+    const E = u.reduce(V.type.compose, null);
+    return { undo: V.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: n, subUnitId: t, objects: { ...e, drawingIds: l } };
   }
   getBackwardDrawingOp(e) {
-    const { unitId: t, subUnitId: i, drawingIds: s } = e, d = [], l = this.getDrawingOrder(t, i), a = [...s];
-    s.forEach((O) => {
-      const o = this._hasDrawingOrder({ unitId: t, subUnitId: i, drawingId: O });
-      if (o === -1 || o === 0)
+    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = [], o = this.getDrawingOrder(n, t), l = [...r];
+    r.forEach((_) => {
+      const s = this._hasDrawingOrder({ unitId: n, subUnitId: t, drawingId: _ });
+      if (s === -1 || s === 0)
         return;
-      const c = F.moveOp([t, i, "order", o], [t, i, "order", o - 1]);
-      d.push(c), a.includes(l[o - 1]) || a.push(l[o - 1]);
+      const c = V.moveOp([n, t, "order", s], [n, t, "order", s - 1]);
+      u.push(c), l.includes(o[s - 1]) || l.push(o[s - 1]);
     });
-    const E = d.reduce(F.type.compose, null);
-    return { undo: F.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: t, subUnitId: i, objects: { ...e, drawingIds: a } };
+    const E = u.reduce(V.type.compose, null);
+    return { undo: V.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: n, subUnitId: t, objects: { ...e, drawingIds: l } };
   }
   getFrontDrawingsOp(e) {
-    const { unitId: t, subUnitId: i, drawingIds: s } = e, d = this._getOrderFromSearchParams(t, i, s), l = [...s], a = this.getDrawingOrder(t, i), E = [];
-    d.forEach((o) => {
-      const { drawingId: c } = o, h = this._getDrawingCount(t, i) - 1, k = F.moveOp([t, i, "order", this._getDrawingOrder(t, i).indexOf(c)], [t, i, "order", h]);
-      E.push(k), l.includes(a[h]) || l.push(a[h]);
+    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = this._getOrderFromSearchParams(n, t, r), o = [...r], l = this.getDrawingOrder(n, t), E = [];
+    u.forEach((s) => {
+      const { drawingId: c } = s, h = this._getDrawingCount(n, t) - 1, S = V.moveOp([n, t, "order", this._getDrawingOrder(n, t).indexOf(c)], [n, t, "order", h]);
+      E.push(S), o.includes(l[h]) || o.push(l[h]);
     });
-    const W = E.reduce(F.type.compose, null);
-    return { undo: F.type.invertWithDoc(W, this.drawingManagerData), redo: W, unitId: t, subUnitId: i, objects: { ...e, drawingIds: l } };
+    const x = E.reduce(V.type.compose, null);
+    return { undo: V.type.invertWithDoc(x, this.drawingManagerData), redo: x, unitId: n, subUnitId: t, objects: { ...e, drawingIds: o } };
   }
   getBackDrawingsOp(e) {
-    const { unitId: t, subUnitId: i, drawingIds: s } = e, d = this._getOrderFromSearchParams(t, i, s, !0), l = [...s], a = this.getDrawingOrder(t, i), E = [];
-    d.forEach((o) => {
-      const { drawingId: c } = o, h = F.moveOp([t, i, "order", this._getDrawingOrder(t, i).indexOf(c)], [t, i, "order", 0]);
-      E.push(h), l.includes(a[0]) || l.push(a[0]);
+    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = this._getOrderFromSearchParams(n, t, r, !0), o = [...r], l = this.getDrawingOrder(n, t), E = [];
+    u.forEach((s) => {
+      const { drawingId: c } = s, h = V.moveOp([n, t, "order", this._getDrawingOrder(n, t).indexOf(c)], [n, t, "order", 0]);
+      E.push(h), o.includes(l[0]) || o.push(l[0]);
     });
-    const W = E.reduce(F.type.compose, null);
-    return { undo: F.type.invertWithDoc(W, this.drawingManagerData), redo: W, unitId: t, subUnitId: i, objects: { ...e, drawingIds: l } };
+    const x = E.reduce(V.type.compose, null);
+    return { undo: V.type.invertWithDoc(x, this.drawingManagerData), redo: x, unitId: n, subUnitId: t, objects: { ...e, drawingIds: o } };
   }
-  _getDrawingCount(e, t) {
-    return this.getDrawingOrder(e, t).length || 0;
+  _getDrawingCount(e, n) {
+    return this.getDrawingOrder(e, n).length || 0;
   }
-  _getOrderFromSearchParams(e, t, i, s = !1) {
-    return i.map((d) => {
-      const l = this._hasDrawingOrder({ unitId: e, subUnitId: t, drawingId: d });
-      return { drawingId: d, zIndex: l };
-    }).sort(s === !1 ? Nt : Rt);
+  _getOrderFromSearchParams(e, n, t, r = !1) {
+    return t.map((u) => {
+      const o = this._hasDrawingOrder({ unitId: e, subUnitId: n, drawingId: u });
+      return { drawingId: u, zIndex: o };
+    }).sort(r === !1 ? Nt : Rt);
   }
   _hasDrawingOrder(e) {
     if (e == null)
       return -1;
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    return this._establishDrawingMap(t, i), this._getDrawingOrder(t, i).indexOf(s);
+    const { unitId: n, subUnitId: t, drawingId: r } = e;
+    return this._establishDrawingMap(n, t), this._getDrawingOrder(n, t).indexOf(r);
   }
   _getCurrentBySearch(e) {
-    var d, l, a;
+    var u, o, l;
     if (e == null)
       return;
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    return (a = (l = (d = this.drawingManagerData[t]) == null ? void 0 : d[i]) == null ? void 0 : l.data) == null ? void 0 : a[s];
+    const { unitId: n, subUnitId: t, drawingId: r } = e;
+    return (l = (o = (u = this.drawingManagerData[n]) == null ? void 0 : u[t]) == null ? void 0 : o.data) == null ? void 0 : l[r];
   }
   _getOldBySearch(e) {
-    var d, l, a;
+    var u, o, l;
     if (e == null)
       return;
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    return (a = (l = (d = this._oldDrawingManagerData[t]) == null ? void 0 : d[i]) == null ? void 0 : l.data) == null ? void 0 : a[s];
+    const { unitId: n, subUnitId: t, drawingId: r } = e;
+    return (l = (o = (u = this._oldDrawingManagerData[n]) == null ? void 0 : u[t]) == null ? void 0 : o.data) == null ? void 0 : l[r];
   }
-  _establishDrawingMap(e, t, i) {
-    var s;
-    return this.drawingManagerData[e] || (this.drawingManagerData[e] = {}), this.drawingManagerData[e][t] || (this.drawingManagerData[e][t] = {
+  _establishDrawingMap(e, n, t) {
+    var r;
+    return this.drawingManagerData[e] || (this.drawingManagerData[e] = {}), this.drawingManagerData[e][n] || (this.drawingManagerData[e][n] = {
       data: {},
       order: []
-    }), i == null ? null : (s = this.drawingManagerData[e][t].data) == null ? void 0 : s[i];
+    }), t == null ? null : (r = this.drawingManagerData[e][n].data) == null ? void 0 : r[t];
   }
   _addByParam(e) {
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    this._establishDrawingMap(t, i, s);
-    const d = F.insertOp([t, i, "data", s], e), l = F.insertOp([t, i, "order", this._getDrawingOrder(t, i).length], s), a = [d, l].reduce(F.type.compose, null), E = F.type.invertWithDoc(a, this.drawingManagerData);
-    return { op: a, invertOp: E };
+    const { unitId: n, subUnitId: t, drawingId: r } = e;
+    this._establishDrawingMap(n, t, r);
+    const u = V.insertOp([n, t, "data", r], e), o = V.insertOp([n, t, "order", this._getDrawingOrder(n, t).length], r), l = [u, o].reduce(V.type.compose, null), E = V.type.invertWithDoc(l, this.drawingManagerData);
+    return { op: l, invertOp: E };
   }
   _removeByParam(e) {
     if (e == null)
       return { op: [], invertOp: [] };
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    if (this._establishDrawingMap(t, i, s) == null)
+    const { unitId: n, subUnitId: t, drawingId: r } = e;
+    if (this._establishDrawingMap(n, t, r) == null)
       return { op: [], invertOp: [] };
-    const l = F.removeOp([t, i, "data", s], !0), a = F.removeOp([t, i, "order", this._getDrawingOrder(t, i).indexOf(s)], !0), E = [l, a].reduce(F.type.compose, null), W = F.type.invertWithDoc(E, this.drawingManagerData);
-    return { op: E, invertOp: W };
+    const o = V.removeOp([n, t, "data", r], !0), l = V.removeOp([n, t, "order", this._getDrawingOrder(n, t).indexOf(r)], !0), E = [o, l].reduce(V.type.compose, null), x = V.type.invertWithDoc(E, this.drawingManagerData);
+    return { op: E, invertOp: x };
   }
   _updateByParam(e) {
-    const { unitId: t, subUnitId: i, drawingId: s } = e, d = this._establishDrawingMap(t, i, s);
-    if (d == null)
+    const { unitId: n, subUnitId: t, drawingId: r } = e, u = this._establishDrawingMap(n, t, r);
+    if (u == null)
       return { op: [], invertOp: [] };
-    const a = this._getUpdateParamCompareOp(e, d).reduce(F.type.compose, null), E = F.type.invertWithDoc(a, this.drawingManagerData);
-    return { op: a, invertOp: E };
+    const l = this._getUpdateParamCompareOp(e, u).reduce(V.type.compose, null), E = V.type.invertWithDoc(l, this.drawingManagerData);
+    return { op: l, invertOp: E };
   }
   // private _initializeDrawingData(updateParam: T, oldParam: T) {
   //     Object.keys(updateParam).forEach((key) => {
@@ -1840,22 +1860,22 @@ class Vt {
   //         }
   //     });
   // }
-  _getUpdateParamCompareOp(e, t) {
-    const { unitId: i, subUnitId: s, drawingId: d } = e, l = [];
-    return Object.keys(e).forEach((a) => {
-      const E = e[a], W = t[a];
-      W !== E && l.push(
-        F.replaceOp([i, s, "data", d, a], W, E)
+  _getUpdateParamCompareOp(e, n) {
+    const { unitId: t, subUnitId: r, drawingId: u } = e, o = [];
+    return Object.keys(e).forEach((l) => {
+      const E = e[l], x = n[l];
+      x !== E && o.push(
+        V.replaceOp([t, r, "data", u, l], x, E)
       );
-    }), l;
+    }), o;
   }
-  _getDrawingData(e, t) {
-    var i, s;
-    return ((s = (i = this.drawingManagerData[e]) == null ? void 0 : i[t]) == null ? void 0 : s.data) || {};
+  _getDrawingData(e, n) {
+    var t, r;
+    return ((r = (t = this.drawingManagerData[e]) == null ? void 0 : t[n]) == null ? void 0 : r.data) || {};
   }
-  _getDrawingOrder(e, t) {
-    var i, s;
-    return ((s = (i = this.drawingManagerData[e]) == null ? void 0 : i[t]) == null ? void 0 : s.order) || [];
+  _getDrawingOrder(e, n) {
+    var t, r;
+    return ((r = (t = this.drawingManagerData[e]) == null ? void 0 : t[n]) == null ? void 0 : r.order) || [];
   }
   getDrawingVisible() {
     return this._visible;
@@ -1870,73 +1890,71 @@ class Vt {
     this._editable = e;
   }
 }
-class Ft extends Vt {
+class tn extends en {
 }
-function dn({ unitId: n, subUnitId: e, drawingId: t }, i) {
-  return typeof i == "number" ? `${n}#-#${e}#-#${t}#-#${i}` : `${n}#-#${e}#-#${t}`;
+function _n({ unitId: a, subUnitId: e, drawingId: n }, t) {
+  return typeof t == "number" ? `${a}#-#${e}#-#${n}#-#${t}` : `${a}#-#${e}#-#${n}`;
 }
-const fn = async (n) => new Promise((e, t) => {
-  const i = new Image();
-  i.src = n, i.onload = () => {
+const vn = async (a) => new Promise((e, n) => {
+  const t = new Image();
+  t.src = a, t.onload = () => {
     e({
-      width: i.width,
-      height: i.height,
-      image: i
+      width: t.width,
+      height: t.height,
+      image: t
     });
-  }, i.onerror = (s) => {
-    t(s);
+  }, t.onerror = (r) => {
+    n(r);
   };
-});
-var et = /* @__PURE__ */ ((n) => (n.URL = "URL", n.UUID = "UUID", n.BASE64 = "BASE64", n))(et || {}), Ze = /* @__PURE__ */ ((n) => (n.SUCCUSS = "0", n.ERROR_EXCEED_SIZE = "1", n.ERROR_IMAGE_TYPE = "2", n.ERROR_UPLOAD_COUNT_LIMIT = "3", n.ERROR_IMAGE = "4", n))(Ze || {});
-const qt = Ct("core.image-io.service");
-class zt {
+}), nn = "drawing.config", rn = {}, sn = xt("univer.drawing-manager.service");
+class on {
   constructor() {
-    V(this, "_waitCount", 0);
-    V(this, "_change$", new we());
-    V(this, "change$", this._change$);
-    V(this, "_imageSourceCache", /* @__PURE__ */ new Map());
+    F(this, "_waitCount", 0);
+    F(this, "_change$", new be());
+    F(this, "change$", this._change$);
+    F(this, "_imageSourceCache", /* @__PURE__ */ new Map());
   }
   setWaitCount(e) {
     this._waitCount = e, this._change$.next(e);
   }
-  getImageSourceCache(e, t) {
-    if (t === et.BASE64) {
-      const i = new Image();
-      return i.src = e, i;
+  getImageSourceCache(e, n) {
+    if (n === at.BASE64) {
+      const t = new Image();
+      return t.src = e, t;
     }
     return this._imageSourceCache.get(e);
   }
-  addImageSourceCache(e, t, i) {
-    t === et.BASE64 || i == null || this._imageSourceCache.set(e, i);
+  addImageSourceCache(e, n, t) {
+    n === at.BASE64 || t == null || this._imageSourceCache.set(e, t);
   }
   async getImage(e) {
     return Promise.resolve(e);
   }
   async saveImage(e) {
-    return new Promise((t, i) => {
-      if (!Bt.includes(e.type)) {
-        i(new Error(Ze.ERROR_IMAGE_TYPE)), this._decreaseWaiting();
+    return new Promise((n, t) => {
+      if (!Ht.includes(e.type)) {
+        t(new Error(et.ERROR_IMAGE_TYPE)), this._decreaseWaiting();
         return;
       }
-      if (e.size > Gt) {
-        i(new Error(Ze.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
+      if (e.size > Vt) {
+        t(new Error(et.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
         return;
       }
-      const s = new FileReader();
-      s.readAsDataURL(e), s.onload = (d) => {
+      const r = new FileReader();
+      r.readAsDataURL(e), r.onload = (u) => {
         var E;
-        const l = (E = d.target) == null ? void 0 : E.result;
-        if (l == null) {
-          i(new Error(Ze.ERROR_IMAGE)), this._decreaseWaiting();
+        const o = (E = u.target) == null ? void 0 : E.result;
+        if (o == null) {
+          t(new Error(et.ERROR_IMAGE)), this._decreaseWaiting();
           return;
         }
-        const a = kt.generateRandomId(6);
-        t({
-          imageId: a,
-          imageSourceType: et.BASE64,
-          source: l,
-          base64Cache: l,
-          status: Ze.SUCCUSS
+        const l = Bt.generateRandomId(6);
+        n({
+          imageId: l,
+          imageSourceType: at.BASE64,
+          source: o,
+          base64Cache: o,
+          status: et.SUCCUSS
         }), this._decreaseWaiting();
       };
     });
@@ -1945,54 +1963,48 @@ class zt {
     this._waitCount -= 1, this._change$.next(this._waitCount);
   }
 }
-const hn = "__default_document_sub_component_id20231101__";
-var Xt = /* @__PURE__ */ ((n) => (n[n.forward = 0] = "forward", n[n.backward = 1] = "backward", n[n.front = 2] = "front", n[n.back = 3] = "back", n))(Xt || {}), Yt = /* @__PURE__ */ ((n) => (n[n.UNRECOGNIZED = -1] = "UNRECOGNIZED", n[n.DRAWING_IMAGE = 0] = "DRAWING_IMAGE", n[n.DRAWING_SHAPE = 1] = "DRAWING_SHAPE", n[n.DRAWING_CHART = 2] = "DRAWING_CHART", n[n.DRAWING_TABLE = 3] = "DRAWING_TABLE", n[n.DRAWING_SMART_ART = 4] = "DRAWING_SMART_ART", n[n.DRAWING_VIDEO = 5] = "DRAWING_VIDEO", n[n.DRAWING_GROUP = 6] = "DRAWING_GROUP", n[n.DRAWING_UNIT = 7] = "DRAWING_UNIT", n[n.DRAWING_DOM = 8] = "DRAWING_DOM", n))(Yt || {});
-const Zt = Ct("univer.drawing-manager.service"), Jt = "drawing.config", Qt = {};
-var en = Object.defineProperty, tn = Object.getOwnPropertyDescriptor, nn = (n, e, t, i) => {
-  for (var s = i > 1 ? void 0 : i ? tn(e, t) : e, d = n.length - 1, l; d >= 0; d--)
-    (l = n[d]) && (s = (i ? l(e, t, s) : l(s)) || s);
-  return i && s && en(e, t, s), s;
-}, wt = (n, e) => (t, i) => e(t, i, n);
-const rn = "UNIVER_DRAWING_PLUGIN";
-var ot;
-let It = (ot = class extends Tt {
-  constructor(n = Qt, e, t) {
-    super(), this._config = n, this._injector = e, this._configService = t;
-    const { ...i } = this._config;
-    this._configService.setConfig(Jt, i);
+var an = Object.defineProperty, ln = Object.getOwnPropertyDescriptor, un = (a, e, n, t) => {
+  for (var r = t > 1 ? void 0 : t ? ln(e, n) : e, u = a.length - 1, o; u >= 0; u--)
+    (o = a[u]) && (r = (t ? o(e, n, r) : o(r)) || r);
+  return t && r && an(e, n, r), r;
+}, Pt = (a, e) => (n, t) => e(n, t, a);
+const cn = "UNIVER_DRAWING_PLUGIN";
+var dt;
+let Tt = (dt = class extends Lt {
+  constructor(a = rn, e, n) {
+    super(), this._config = a, this._injector = e, this._configService = n;
+    const { ...t } = this._config;
+    this._configService.setConfig(nn, t);
   }
   onStarting() {
     this._initDependencies();
   }
   _initDependencies() {
-    var t;
-    $t([
-      [qt, { useClass: zt }],
-      [Zt, { useClass: Ft }]
-    ], (t = this._config) == null ? void 0 : t.override).forEach((i) => this._injector.add(i));
-  }
-}, V(ot, "pluginName", rn), ot);
-It = nn([
-  wt(1, St(jt)),
-  wt(2, Wt)
-], It);
+    var n;
+    qt([
+      [Ft, { useClass: on }],
+      [sn, { useClass: tn }]
+    ], (n = this._config) == null ? void 0 : n.override).forEach((t) => this._injector.add(t));
+  }
+}, F(dt, "pluginName", cn), dt);
+Tt = un([
+  Pt(1, Wt(Gt)),
+  Pt(2, Kt)
+], Tt);
 export {
-  Xt as ArrangeTypeEnum,
-  hn as DEFAULT_DOCUMENT_SUB_COMPONENT_ID,
-  Bt as DRAWING_IMAGE_ALLOW_IMAGE_LIST,
-  Gt as DRAWING_IMAGE_ALLOW_SIZE,
-  un as DRAWING_IMAGE_COUNT_LIMIT,
-  cn as DRAWING_IMAGE_HEIGHT_LIMIT,
-  an as DRAWING_IMAGE_WIDTH_LIMIT,
-  Ft as DrawingManagerService,
-  Yt as DrawingTypeEnum,
-  Zt as IDrawingManagerService,
-  qt as IImageIoService,
-  zt as ImageIoService,
-  et as ImageSourceType,
-  Ze as ImageUploadStatusType,
-  Vt as UnitDrawingService,
-  It as UniverDrawingPlugin,
-  dn as getDrawingShapeKeyByDrawingSearch,
-  fn as getImageSize
+  Ht as DRAWING_IMAGE_ALLOW_IMAGE_LIST,
+  Vt as DRAWING_IMAGE_ALLOW_SIZE,
+  yn as DRAWING_IMAGE_COUNT_LIMIT,
+  gn as DRAWING_IMAGE_HEIGHT_LIMIT,
+  pn as DRAWING_IMAGE_WIDTH_LIMIT,
+  tn as DrawingManagerService,
+  sn as IDrawingManagerService,
+  wn as IImageIoService,
+  on as ImageIoService,
+  bn as ImageSourceType,
+  Cn as ImageUploadStatusType,
+  en as UnitDrawingService,
+  Tt as UniverDrawingPlugin,
+  _n as getDrawingShapeKeyByDrawingSearch,
+  vn as getImageSize
 };