@univerjs/drawing 0.1.13

package/lib/es/index.js

@@ -0,0 +1,2053 @@
+var Dt = Object.defineProperty;
+var Ut = (t, e, n) => e in t ? Dt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var q = (t, e, n) => (Ut(t, typeof e != "symbol" ? e + "" : e, n), n);
+import { Subject as we } from "rxjs";
+import { sortRules as Mt, sortRulesByDesc as Nt, Tools as kt, Plugin as Rt, mergeOverrideWithDependencies as St } from "@univerjs/core";
+import { createIdentifier as It, Inject as jt, Injector as Tt } from "@wendellhu/redi";
+const on = 500, ln = 500, an = 10, $t = 5 * 1024 * 1024, Wt = ["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 = {}, Ct = {}, ct = {};
+Object.defineProperty(ct, "__esModule", { value: !0 });
+function Gt(t, e) {
+  if (Array.isArray(e))
+    return !1;
+  for (let n in t)
+    if (!ut(t[n], e[n]))
+      return !1;
+  for (let n in e)
+    if (t[n] === void 0)
+      return !1;
+  return !0;
+}
+function Bt(t, e) {
+  if (!Array.isArray(e) || t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; n++)
+    if (!ut(t[n], e[n]))
+      return !1;
+  return !0;
+}
+function ut(t, e) {
+  return t === e ? !0 : t === null || e === null || typeof t != "object" || typeof e != "object" ? !1 : Array.isArray(t) ? Bt(t, e) : Gt(t, e);
+}
+ct.default = ut;
+var dt = {};
+Object.defineProperty(dt, "__esModule", { value: !0 });
+function lt(t) {
+  if (t === null)
+    return null;
+  if (Array.isArray(t))
+    return t.map(lt);
+  if (typeof t == "object") {
+    const e = {};
+    for (let n in t)
+      e[n] = lt(t[n]);
+    return e;
+  } else
+    return t;
+}
+dt.default = lt;
+var ft = {};
+(function(t) {
+  Object.defineProperty(t, "__esModule", { value: !0 }), t.eachChildOf = t.advancer = t.readCursor = t.writeCursor = t.WriteCursor = t.ReadCursor = t.isValidPathItem = void 0;
+  function e(O, o) {
+    if (!O)
+      throw new Error(o);
+  }
+  const n = (O) => O != null && typeof O == "object" && !Array.isArray(O), s = (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 i(O, o) {
+    for (let c in O) {
+      const h = c;
+      o.write(h, O[h]);
+    }
+  }
+  t.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--, n(this.container[this.idx]) && this.idx--);
+    }
+    getPath() {
+      const o = [];
+      let c = this.container, h = this.parents.length - 1, R = this.idx;
+      for (; R >= 0; )
+        o.unshift(c[R]), R === 0 ? (R = this.indexes[h * 2], c = this.parents[h--]) : R -= n(c[R - 1]) ? 2 : 1;
+      return o;
+    }
+  }
+  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 && n(o = this.container[this.idx + 1]) ? o : null;
+    }
+    descendFirst() {
+      let o = this.idx + 1;
+      if (!this.container || o >= this.container.length || n(this.container[o]) && o + 1 >= this.container.length)
+        return !1;
+      n(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, R) {
+      this.container = o, this.idx = c, this.parents = h.slice(), this.indexes = R.slice();
+    }
+    clone() {
+      const o = new l();
+      return o._init(this.container, this.idx, this.parents, this.indexes), o;
+    }
+    *[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(o, c) {
+      const h = this.getComponent();
+      h && c(h, o);
+      for (const R of this)
+        o && o.descend(R), this.traverse(o, c), o && o.ascend();
+    }
+    eachPick(o, c) {
+      this.traverse(o, (h, R) => {
+        h.p != null && c(h.p, R);
+      });
+    }
+    eachDrop(o, c) {
+      this.traverse(o, (h, R) => {
+        h.d != null && c(h.d, R);
+      });
+    }
+  }
+  t.ReadCursor = l;
+  class a extends d {
+    constructor(o = null) {
+      super(o), this.pendingDescent = [], this._op = o;
+    }
+    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 && 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 {
+          if (!Array.isArray(this.container[h])) {
+            const R = this.container.splice(h, this.container.length - h);
+            this.container.push(R), this.lcIdx > -1 && (this.lcIdx = h);
+          }
+          for (this.indexes.push(this.idx), this.parents.push(this.container), this.lcIdx !== -1 && (e(s(c, this.container[this.lcIdx][0])), h = this.lcIdx + 1, this.lcIdx = -1); h < this.container.length && s(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 R = [c];
+            this.container.splice(h, 0, R), this.container = R;
+          }
+        }
+      }
+      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 && n(this.container[o]))
+        return this.container[o];
+      {
+        const c = {};
+        return this.container.splice(o, 0, c), c;
+      }
+    }
+    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 (!t.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 = i) {
+      if (o === null)
+        return;
+      if (e(Array.isArray(o)), o === this._op)
+        throw Error("Cannot merge into my own tree");
+      const h = this.lcIdx, R = 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);
+      }
+      for (; Z--; )
+        this.ascend();
+      this.lcIdx = this.parents.length === R ? 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;
+    }
+  }
+  t.WriteCursor = a, t.writeCursor = () => new a(), t.readCursor = (O) => new l(O);
+  function E(O, o, c) {
+    let h, R;
+    R = h = O ? O.descendFirst() : !1;
+    function Z(pe) {
+      let J;
+      for (; R; ) {
+        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)), s(J, pe))
+            return null;
+          if (J === pe && !xe)
+            return O;
+        }
+        c && typeof J == "number" && c(J, O.getComponent()), R = O.nextSibling();
+      }
+      return null;
+    }
+    return Z.end = () => {
+      h && O.ascend();
+    }, Z;
+  }
+  t.advancer = E;
+  function W(O, o, c) {
+    let h, R, Z, pe;
+    for (h = R = 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 && (s(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());
+    }
+    R && O.ascend(), pe && o.ascend();
+  }
+  t.eachChildOf = W;
+})(ft);
+var ht = {};
+(function(t) {
+  Object.defineProperty(t, "__esModule", { value: !0 }), t.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";
+  }(t.ConflictType || (t.ConflictType = {}));
+})(ht);
+var it = {}, Ve = {}, vt;
+function pt() {
+  return vt || (vt = 1, Object.defineProperty(Ve, "__esModule", { value: !0 }), Ve.uniToStrPos = Ve.strPosToUni = void 0, Ve.strPosToUni = (t, e = t.length) => {
+    let n = 0, s = 0;
+    for (; s < e; s++) {
+      const i = t.charCodeAt(s);
+      i >= 55296 && i <= 57343 && (n++, s++);
+    }
+    if (s !== e)
+      throw Error("Invalid offset - splits unicode bytes");
+    return s - n;
+  }, Ve.uniToStrPos = (t, e) => {
+    let n = 0;
+    for (; e > 0; e--) {
+      const s = t.charCodeAt(n);
+      n += s >= 55296 && s <= 57343 ? 2 : 1;
+    }
+    return n;
+  }), Ve;
+}
+var st = {}, yt;
+function at() {
+  return yt || (yt = 1, function(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.uniSlice = t.dlen = t.eachOp = void 0;
+    const e = pt(), 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];
+        switch (typeof L) {
+          case "object":
+            if (typeof L.d != "number" && typeof L.d != "string")
+              throw Error("Delete must be number or string");
+            if (t.dlen(L.d) <= 0)
+              throw Error("Deletes must not be empty");
+            break;
+          case "string":
+            if (!(L.length > 0))
+              throw Error("Inserts cannot be empty");
+            break;
+          case "number":
+            if (!(L > 0))
+              throw Error("Skip components must be >0");
+            if (typeof _ == "number")
+              throw Error("Adjacent skip components should be combined");
+            break;
+        }
+        _ = L;
+      }
+      if (typeof _ == "number")
+        throw Error("Op has a trailing skip");
+    };
+    function s(f, _) {
+      let w = 0, L = 0;
+      for (let X = 0; X < f.length; X++) {
+        const H = f[X];
+        switch (_(H, w, L), typeof H) {
+          case "object":
+            w += t.dlen(H.d);
+            break;
+          case "string":
+            L += e.strPosToUni(H);
+            break;
+          case "number":
+            w += H, L += H;
+            break;
+        }
+      }
+    }
+    t.eachOp = s;
+    function i(f, _) {
+      const w = [], L = a(w);
+      return s(f, (X, H, Ae) => {
+        L(_(X, H, Ae));
+      }), o(w);
+    }
+    const d = (f) => f, l = (f) => i(f, d);
+    t.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 : t.dlen(w.d) + t.dlen(_.d);
+          } else
+            f[f.length - 1] += _;
+        else
+          f.push(_);
+    }, E = (f) => typeof f == "number" ? f : typeof f == "string" ? e.strPosToUni(f) : typeof f.d == "number" ? f.d : e.strPosToUni(f.d);
+    t.uniSlice = (f, _, w) => {
+      const L = e.uniToStrPos(f, _), X = w == null ? 1 / 0 : e.uniToStrPos(f, w);
+      return f.slice(L, X);
+    };
+    const W = (f, _, w) => typeof f == "number" ? w == null ? f - _ : Math.min(f, w) - _ : t.uniSlice(f, _, w), O = (f) => {
+      let _ = 0, w = 0;
+      return { take: (H, Ae) => {
+        if (_ === f.length)
+          return H === -1 ? null : H;
+        const ue = f[_];
+        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 || Ae === "i" || e.strPosToUni(ue.slice(w)) <= H)
+            return ne = ue.slice(w), ++_, w = 0, ne;
+          {
+            const ae = w + e.uniToStrPos(ue.slice(w), H);
+            return ne = ue.slice(w, ae), w = ae, ne;
+          }
+        } else {
+          if (H === -1 || Ae === "d" || t.dlen(ue.d) - w <= H)
+            return ne = { d: W(ue.d, w) }, ++_, w = 0, ne;
+          {
+            let ae = W(ue.d, w, w + H);
+            return w += H, { d: ae };
+          }
+        }
+      }, 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'");
+      n(f), n(_);
+      const L = [], X = a(L), { take: H, peek: Ae } = O(f);
+      for (let ne = 0; ne < _.length; ne++) {
+        const ae = _[ne];
+        let ge, Pe;
+        switch (typeof ae) {
+          case "number":
+            for (ge = ae; ge > 0; )
+              Pe = H(ge, "i"), X(Pe), typeof Pe != "string" && (ge -= E(Pe));
+            break;
+          case "string":
+            w === "left" && typeof Ae() == "string" && X(H(-1)), X(e.strPosToUni(ae));
+            break;
+          case "object":
+            for (ge = t.dlen(ae.d); ge > 0; )
+              switch (Pe = H(ge, "i"), typeof Pe) {
+                case "number":
+                  ge -= Pe;
+                  break;
+                case "string":
+                  X(Pe);
+                  break;
+                case "object":
+                  ge -= t.dlen(Pe.d);
+              }
+            break;
+        }
+      }
+      let ue;
+      for (; ue = H(-1); )
+        X(ue);
+      return o(L);
+    }
+    function h(f, _) {
+      n(f), n(_);
+      const w = [], L = a(w), { take: X } = O(f);
+      for (let Ae = 0; Ae < _.length; Ae++) {
+        const ue = _[Ae];
+        let ne, ae;
+        switch (typeof ue) {
+          case "number":
+            for (ne = ue; ne > 0; )
+              ae = X(ne, "d"), L(ae), typeof ae != "object" && (ne -= E(ae));
+            break;
+          case "string":
+            L(ue);
+            break;
+          case "object":
+            ne = t.dlen(ue.d);
+            let ge = 0;
+            for (; ge < ne; )
+              switch (ae = X(ne - ge, "d"), typeof ae) {
+                case "number":
+                  L({ d: W(ue.d, ge, ge + ae) }), ge += ae;
+                  break;
+                case "string":
+                  ge += e.strPosToUni(ae);
+                  break;
+                case "object":
+                  L(ae);
+              }
+            break;
+        }
+      }
+      let H;
+      for (; H = X(-1); )
+        L(H);
+      return o(w);
+    }
+    const R = (f, _) => {
+      let w = 0;
+      for (let L = 0; L < _.length && f > w; L++) {
+        const X = _[L];
+        switch (typeof X) {
+          case "number": {
+            w += X;
+            break;
+          }
+          case "string":
+            const H = e.strPosToUni(X);
+            w += H, f += H;
+            break;
+          case "object":
+            f -= Math.min(t.dlen(X.d), f - w);
+            break;
+        }
+      }
+      return f;
+    }, Z = (f, _) => typeof f == "number" ? R(f, _) : f.map((w) => R(w, _));
+    function pe(f, _, w) {
+      return i(f, (L, X) => typeof L == "object" && typeof L.d == "number" ? { d: w.slice(_, X, X + L.d) } : L);
+    }
+    function J(f) {
+      return i(f, (_) => {
+        switch (typeof _) {
+          case "object":
+            if (typeof _.d == "number")
+              throw Error("Cannot invert text op: Deleted characters missing from operation. makeInvertible must be called first.");
+            return _.d;
+          case "string":
+            return { d: _ };
+          case "number":
+            return _;
+        }
+      });
+    }
+    function Ie(f) {
+      return i(f, (_) => typeof _ == "object" && typeof _.d == "string" ? { d: e.strPosToUni(_.d) } : _);
+    }
+    function xe(f) {
+      let _ = !0;
+      return s(f, (w) => {
+        typeof w == "object" && typeof w.d == "number" && (_ = !1);
+      }), _;
+    }
+    function ve(f) {
+      return {
+        name: "text-unicode",
+        uri: "http://sharejs.org/types/text-unicode",
+        trim: o,
+        normalize: l,
+        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")
+            throw Error("Initial data must be a string");
+          return f.create(_);
+        },
+        /** Apply an operation to a document snapshot
+         */
+        apply(_, w) {
+          n(w);
+          const L = f.builder(_);
+          for (let X = 0; X < w.length; X++) {
+            const H = w[X];
+            switch (typeof H) {
+              case "number":
+                L.skip(H);
+                break;
+              case "string":
+                L.append(H);
+                break;
+              case "object":
+                L.del(t.dlen(H.d));
+                break;
+            }
+          }
+          return L.build();
+        },
+        transform: c,
+        compose: h,
+        transformPosition: R,
+        transformSelection: Z,
+        isInvertible: xe,
+        makeInvertible(_, w) {
+          return pe(_, w, f);
+        },
+        stripInvertible: Ie,
+        invert: J,
+        invertWithDoc(_, w) {
+          return J(pe(_, w, f));
+        },
+        isNoop: (_) => _.length === 0
+      };
+    }
+    t.default = ve;
+  }(st)), st;
+}
+var Qe = {}, mt;
+function xt() {
+  if (mt)
+    return Qe;
+  mt = 1, Object.defineProperty(Qe, "__esModule", { value: !0 });
+  const t = at(), e = pt();
+  function n(s, i) {
+    return {
+      // Returns the text content of the document
+      get: s,
+      // Returns the number of characters in the string
+      getLength() {
+        return s().length;
+      },
+      // Insert the specified text at the given position in the document
+      insert(d, l, a) {
+        const E = e.strPosToUni(s(), d);
+        return i([E, l], a);
+      },
+      remove(d, l, a) {
+        const E = e.strPosToUni(s(), d);
+        return i([E, { d: l }], a);
+      },
+      // 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) {
+        t.eachOp(d, (l, a, E) => {
+          switch (typeof l) {
+            case "string":
+              this.onInsert && this.onInsert(E, l);
+              break;
+            case "object":
+              const W = t.dlen(l.d);
+              this.onRemove && this.onRemove(E, W);
+          }
+        });
+      },
+      onInsert: null,
+      onRemove: null
+    };
+  }
+  return Qe.default = n, n.provides = { text: !0 }, Qe;
+}
+var bt;
+function Lt() {
+  return bt || (bt = 1, function(t) {
+    var e = Ce && Ce.__createBinding || (Object.create ? function(c, h, R, Z) {
+      Z === void 0 && (Z = R), Object.defineProperty(c, Z, { enumerable: !0, get: function() {
+        return h[R];
+      } });
+    } : function(c, h, R, Z) {
+      Z === void 0 && (Z = R), c[Z] = h[R];
+    }), n = Ce && Ce.__setModuleDefault || (Object.create ? function(c, h) {
+      Object.defineProperty(c, "default", { enumerable: !0, value: h });
+    } : function(c, h) {
+      c.default = h;
+    }), s = Ce && Ce.__importStar || function(c) {
+      if (c && c.__esModule)
+        return c;
+      var h = {};
+      if (c != null)
+        for (var R in c)
+          Object.hasOwnProperty.call(c, R) && e(h, c, R);
+      return n(h, c), h;
+    }, i = Ce && Ce.__importDefault || function(c) {
+      return c && c.__esModule ? c : { default: c };
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.type = t.remove = t.insert = void 0;
+    const d = pt(), l = s(at()), a = i(xt()), E = {
+      create(c) {
+        return c;
+      },
+      toString(c) {
+        return c;
+      },
+      builder(c) {
+        if (typeof c != "string")
+          throw Error("Invalid document snapshot: " + c);
+        const h = [];
+        return {
+          skip(R) {
+            let Z = d.uniToStrPos(c, R);
+            if (Z > c.length)
+              throw Error("The op is too long for this document");
+            h.push(c.slice(0, Z)), c = c.slice(Z);
+          },
+          append(R) {
+            h.push(R);
+          },
+          del(R) {
+            c = c.slice(d.uniToStrPos(c, R));
+          },
+          build() {
+            return h.join("") + c;
+          }
+        };
+      },
+      slice: l.uniSlice
+    }, W = l.default(E), O = Object.assign(Object.assign({}, W), { api: a.default });
+    t.type = O, t.insert = (c, h) => h.length === 0 ? [] : c === 0 ? [h] : [c, h], t.remove = (c, h) => l.dlen(h) === 0 ? [] : c === 0 ? [{ d: h }] : [c, { d: h }];
+    var o = at();
+    Object.defineProperty(t, "makeType", { enumerable: !0, get: function() {
+      return o.default;
+    } });
+  }(it)), it;
+}
+(function(t) {
+  var e = Ce && Ce.__importDefault || function(r) {
+    return r && r.__esModule ? r : {
+      default: r
+    };
+  };
+  Object.defineProperty(t, "__esModule", {
+    value: !0
+  }), t.editOp = t.replaceOp = t.insertOp = t.moveOp = t.removeOp = t.type = void 0;
+  const n = e(ct), s = e(dt), i = ft, d = ht;
+  function l(r, u) {
+    if (!r)
+      throw new Error(u);
+  }
+  t.type = {
+    name: "json1",
+    uri: "http://sharejs.org/types/JSONv1",
+    readCursor: i.readCursor,
+    writeCursor: i.writeCursor,
+    create: (r) => r,
+    isNoop: (r) => r == null,
+    setDebug(r) {
+    },
+    registerSubtype: J,
+    checkValidOp: X,
+    normalize: H,
+    apply: Ae,
+    transformPosition: ue,
+    compose: ne,
+    tryTransform: nt,
+    transform: At,
+    makeInvertible: Pe,
+    invert: ae,
+    invertWithDoc: Et,
+    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({}, t.type), {
+      transform: (u, y, A) => _t(r, u, y, A)
+    })
+  };
+  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;
+  }
+  t.removeOp = (r, u = !0) => i.writeCursor().writeAtPath(r, "r", u).get(), t.moveOp = (r, u) => i.writeCursor().writeMove(r, u).get(), t.insertOp = (r, u) => i.writeCursor().writeAtPath(r, "i", u).get(), t.replaceOp = (r, u, y) => i.writeCursor().at(r, (A) => {
+    A.write("r", u), A.write("i", y);
+  }).get(), t.editOp = (r, u, y, A = !1) => i.writeCursor().at(r, (m) => _(m, u, y, A)).get();
+  const R = (r, u) => r != null && (typeof u == "number" ? Array.isArray(r) : typeof r == "object"), Z = (r, u) => R(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(Lt());
+  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, A = !1) => {
+    const [m, C] = typeof u == "string" ? [Ie(u), u] : [u, u.name];
+    !A && 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 X(r) {
+    if (r === null)
+      return;
+    const u = /* @__PURE__ */ new Set(), y = /* @__PURE__ */ new Set(), A = (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));
+        }
+      }
+      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");
+          }
+          b = G, v++, p = 3;
+        } else
+          typeof T == "object" ? (l(p === 1, `Prev not scalar - instead ${p}`), A(T), p = 2) : (l(p !== 3), L(T), l(i.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 A = i.writeCursor();
+    return A.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;
+    }), A.get();
+  }
+  function Ae(r, u) {
+    if (X(u), u === null)
+      return r;
+    const y = [];
+    return function A(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(R(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 = A($, 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 A(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 = A(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(), X(u);
+    const y = i.readCursor(u);
+    let A, 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, A = b.p, m = p)), p >= r.length)
+        break;
+      let I = 0;
+      const T = i.advancer(y, void 0, (g, N) => {
+        O(N) && I++;
+      });
+      $.unshift(T);
+      const G = T(v);
+      if (typeof v == "number" && (r[p] -= I), !G)
+        break;
+    }
+    if ($.forEach((p) => p.end()), C)
+      return null;
+    const j = () => {
+      let p = 0;
+      if (A != null) {
+        const v = y.getPath();
+        p = v.length, r = v.concat(r.slice(m));
+      }
+      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;
+        }
+        let T = 0;
+        const G = i.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 A != null ? y.eachDrop(null, (p) => {
+      p === A && j();
+    }) : j(), r;
+  }
+  function ne(r, u) {
+    if (X(r), X(u), r == null)
+      return u;
+    if (u == null)
+      return r;
+    let y = 0;
+    const A = i.readCursor(r), m = i.readCursor(u), C = i.writeCursor(), $ = [], j = [], p = [], v = [], b = [], I = [], T = /* @__PURE__ */ new Set();
+    A.traverse(null, (g) => {
+      g.p != null && (p[g.p] = A.clone());
+    }), m.traverse(null, (g) => {
+      g.d != null && (v[g.d] = m.clone());
+    });
+    const G = i.writeCursor();
+    return function g(N, re, te, K, se, Te, me, _e) {
+      l(re || te);
+      const oe = a(re), De = a(te), Me = !!De && De.r !== void 0, Le = !!oe && oe.i !== void 0, Ue = oe ? oe.d : null, Ee = De ? De.p : null, $e = (Te || Me) && Ee == null;
+      if (Ee != null)
+        K = v[Ee], me = j[Ee] = new i.WriteCursor();
+      else if (De && De.r !== void 0)
+        K = null;
+      else {
+        const D = a(K);
+        D && D.d != null && (K = null);
+      }
+      const Q = a(K);
+      if (Ue != null)
+        if (N = p[Ue], _e = $[Ue] = new i.WriteCursor(), $e)
+          Te && !Me && _e.write("r", !0);
+        else {
+          const D = b[Ue] = y++;
+          me.write("d", D);
+        }
+      else if (oe && oe.i !== void 0)
+        N = null;
+      else {
+        const D = a(N);
+        D && D.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 D = Ue != null ? b[Ue] : y++;
+          I[Ee] = D, _e.write("p", D);
+        }
+      } else
+        Me && (Le || se !== void 0 || (De.r, _e.write("r", De.r)));
+      const M = $e ? null : ve(oe), P = ve(Q);
+      if ((M || P) && (M && M.name, P && P.name), M && P) {
+        l(M === P);
+        const D = f(oe), x = f(Q), he = M.compose(D, x);
+        _(me, M, he), T.add(Q);
+      } else
+        M ? _(me, M, f(oe)) : P && (_(me, P, f(Q)), T.add(Q));
+      const k = typeof U == "object" && U != null;
+      let z = !1, Y = 0, ee = 0, fe = 0, de = 0, le = 0;
+      const ye = i.advancer(K, (D, x) => o(x) ? de - D - 1 : D - de, (D, x) => {
+        o(x) && de++;
+      }), V = i.advancer(N, (D, x) => O(x) ? Y - D - 1 : D - Y, (D, x) => {
+        O(x) && Y++;
+      });
+      if (i.eachChildOf(re, te, (D, x, he) => {
+        let be, We, He = D, Ne = D, Ye = D;
+        if (typeof D == "number") {
+          let Oe = D + fe;
+          We = ye(Oe), Ne = Oe + de;
+          let ce = D + ee;
+          be = V(ce), o(a(We)) && (be = null), He = ce + Y, Ye = D + le, l(He >= 0, "p1PickKey is negative"), l(Ne >= 0, "p2DropKey is negative");
+          const ke = o(a(x)), Ge = O(a(he));
+          (ke || Ge && !$e) && le--, ke && ee--, Ge && fe--;
+        } else
+          be = V(D), We = ye(D);
+        _e.descend(He), me.descend(Ne);
+        const Xe = k && !o(a(x)) ? U[Ye] : void 0, Se = g(be, x, he, We, Xe, $e, me, _e);
+        var je, S, ie;
+        k && !$e ? Xe !== Se && (z || (U = Array.isArray(U) ? U.slice() : Object.assign({}, U), z = !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();
+      }), V.end(), ye.end(), B != null)
+        B.i = U;
+      else if (!Te && !Me && Ee == null)
+        return U;
+    }(A, A.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()), A.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 i.ReadCursor(r), y = new i.WriteCursor();
+    let A;
+    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 ? (A || (A = /* @__PURE__ */ new Set()), A.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)), !R(v, N))
+            throw Error("Cannot modify child - invalid operation");
+          v[N] = te;
+        }
+        p.ascend();
+      }
+      if (I === void 0)
+        return T ? v : void 0;
+      p.write("r", v);
+    }(u, y, void 0), A && (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] = i.writeCursor()), A.has(b)) {
+          const N = ve(b);
+          if (!N.invert)
+            throw Error(`Cannot invert subtype ${N.name}`);
+          _(v, N, N.invert(f(b)));
+        }
+      }
+      let I = 0, T = 0;
+      const G = i.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 Pe(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 i.ReadCursor(r), A = new i.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", s.default(b)), b = void 0) : I.p != null && (b = void 0)), b;
+    };
+    return j(y, A, u), A.get(), m && (A.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);
+        }
+      }
+      let N = 0, re = 0;
+      const te = i.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, A, u, !1)), A.get();
+  }
+  function Et(r, u) {
+    return ae(Pe(r, u));
+  }
+  const tt = (r) => {
+    if (r == null)
+      return null;
+    const u = r.slice();
+    for (let y = 0; y < r.length; y++) {
+      const A = u[y];
+      Array.isArray(A) && (u[y] = tt(A));
+    }
+    return u;
+  };
+  function nt(r, u, y) {
+    l(y === "left" || y === "right", "Direction must be left or right");
+    const A = y === "left" ? 0 : 1;
+    if (u == null)
+      return {
+        ok: !0,
+        result: r
+      };
+    X(r), X(u);
+    let m = null;
+    const C = [], $ = [], j = [], p = [], v = [], b = [], I = [], T = [], G = [], g = [], N = [], re = [], te = [], K = [], se = [];
+    let Te = 0;
+    const me = i.readCursor(r), _e = i.readCursor(u), oe = i.writeCursor();
+    if (function Q(U, B = null, M) {
+      const P = a(B);
+      P && (P.r !== void 0 ? M = B.clone() : P.p != null && (M = null, b[P.p] = U.clone()));
+      const k = U.getComponent();
+      let z;
+      k && (z = k.p) != null && (v[z] = B ? B.clone() : null, j[z] = U.clone(), M && (g[z] = !0, G[z] = M), P && P.p != null && (K[z] = P.p));
+      const Y = i.advancer(B);
+      for (const ee of U)
+        Q(U, Y(ee), M);
+      Y.end();
+    }(_e, me, null), function Q(U, B, M, P, k) {
+      const z = M.getComponent();
+      let Y, ee = !1;
+      z && ((Y = z.d) != null ? (p[Y] = M.clone(), P != null && (se[P] == null && (se[P] = []), se[P].push(Y)), U = v[Y] || null, B = j[Y] || null, g[Y] ? (k && (N[Y] = !0), k = G[Y] || null) : !k || A !== 1 && K[Y] != null || m == null && (m = {
+        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
+        op1: t.removeOp(k.getPath()),
+        op2: t.moveOp(B.getPath(), M.getPath())
+      }), ee = !0) : z.i !== void 0 && (U = B = null, ee = !0, k && m == null && (m = {
+        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
+        op1: t.removeOp(k.getPath()),
+        op2: t.insertOp(M.getPath(), z.i)
+      })));
+      const fe = a(U);
+      fe && (fe.r !== void 0 ? k = U.clone() : fe.p != null && (fe.p, P = fe.p, k = null));
+      const de = ve(z);
+      de && k && m == null && (m = {
+        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
+        op1: t.removeOp(k.getPath()),
+        op2: t.editOp(M.getPath(), de, f(z), !0)
+      });
+      let le = 0, ye = 0;
+      const V = i.advancer(B, (x, he) => O(he) ? le - x - 1 : x - le, (x, he) => {
+        O(he) && le++;
+      }), D = i.advancer(U);
+      for (const x of M)
+        if (typeof x == "number") {
+          const he = x - ye, be = V(he);
+          ye += +Q(D(he + le), be, M, P, k);
+        } else {
+          const he = V(x);
+          Q(D(x), he, M, P, k);
+        }
+      return V.end(), D.end(), ee;
+    }(me, _e, _e.clone(), null, null), p.map((Q) => Q && Q.get()), m)
+      return {
+        ok: !1,
+        conflict: m
+      };
+    N.map((Q) => !!Q);
+    const De = [];
+    let Me = null;
+    (function Q(U, B, M, P, k) {
+      let z = !1;
+      const Y = a(B);
+      if (O(Y)) {
+        const V = Y.p;
+        V != null ? (M = p[V], P = re[V] = i.writeCursor(), z = !0, k = null) : (M = null, k = B.clone());
+      } else
+        o(a(M)) && (M = null);
+      const ee = U.getComponent();
+      if (ee) {
+        const V = ee.p;
+        V != null ? (k && (T[V] = k), De[V] = k || A === 1 && z ? null : P.getComponent(), C[V] = U.clone(), M && (I[V] = M.clone())) : ee.r !== void 0 && (k || P.write("r", !0), (k || z) && (Me == null && (Me = /* @__PURE__ */ new Set()), Me.add(ee)));
+      }
+      let fe = 0, de = 0;
+      const le = i.advancer(B, void 0, (V, D) => {
+        O(D) && fe++;
+      }), ye = i.advancer(M, (V, D) => o(D) ? ~(V - de) : V - de, (V, D) => {
+        o(D) && de++;
+      });
+      if (U)
+        for (const V of U)
+          if (typeof V == "string") {
+            const D = le(V), x = ye(V);
+            P.descend(V), Q(U, D, x, P, k), P.ascend();
+          } else {
+            const D = le(V), x = V - fe, he = O(a(D)) ? null : ye(x), be = x + de;
+            l(be >= 0), P.descend(be), Q(U, D, he, P, k), P.ascend();
+          }
+      le.end(), ye.end();
+    })(me, _e, _e.clone(), oe, null), oe.reset();
+    let Le = [];
+    if (function Q(U, B, M, P, k, z) {
+      l(B);
+      const Y = B.getComponent();
+      let ee = a(P), fe = !1;
+      const de = (S, ie, Oe) => S ? t.moveOp(S.getPath(), ie.getPath()) : t.insertOp(ie.getPath(), Oe.i);
+      if (o(Y)) {
+        const S = Y.d;
+        S != null && ($[S] = B.clone());
+        const ie = S != null ? De[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] : n.default(ee.i, Y.i), Oe || ce != null && A !== 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, P, ee)
+          })), Oe || (z ? m == null && (m = {
+            type: d.ConflictType.RM_UNEXPECTED_CONTENT,
+            op1: de(S != null ? C[S] : null, B, Y),
+            op2: t.removeOp(z.getPath())
+          }) : (S != null ? (Le[Te] = S, k.write("d", ie.p = Te++)) : k.write("i", s.default(Y.i)), fe = !0));
+        } else if (S != null && !ie) {
+          const ce = T[S];
+          ce && (z = ce.clone());
+        }
+        S != null ? (U = C[S], M = b[S], P = I[S]) : Y.i !== void 0 && (U = M = null, Oe || (P = null));
+      } else
+        O(a(U)) && (U = M = P = 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] ? (P = null, z = M.clone()) : S != null && (P = p[S], A !== 1 && K[S] != null || ((k = te[S]) || (k = te[S] = i.writeCursor()), k.reset(), z = null));
+      } else
+        !o(Y) && o(ee) && (P = null);
+      ee = P != null ? P.getComponent() : null;
+      const V = ve(Y);
+      if (V) {
+        const S = f(Y);
+        if (z)
+          m == null && (m = {
+            type: d.ConflictType.RM_UNEXPECTED_CONTENT,
+            op1: t.editOp(B.getPath(), V, S, !0),
+            op2: t.removeOp(z.getPath())
+          });
+        else {
+          const ie = ve(ee);
+          let Oe;
+          if (ie) {
+            if (V !== ie)
+              throw Error("Transforming incompatible types");
+            const ce = f(ee);
+            Oe = V.transform(S, ce, y);
+          } else
+            Oe = s.default(S);
+          _(k, V, Oe);
+        }
+      }
+      let D = 0, x = 0, he = 0, be = 0, We = 0, He = 0, Ne = U != null && U.descendFirst(), Ye = Ne;
+      const Xe = i.advancer(M, void 0, (S, ie) => {
+        O(ie) && he++;
+      });
+      let Se = P != null && P.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 += D;
+              const Re = U.getComponent(), ze = O(Re);
+              if (Be > ce || Be === ce && (!ze || A === 0 && Oe))
+                break;
+              if (ze) {
+                D--;
+                const Ke = Re.p;
+                K.includes(Ke), Re.d, a(te[Re.d]), O(a(te[Re.d])), (Re.r === void 0 || Me && Me.has(Re)) && (Ke == null || !De[Ke] || A !== 1 && K.includes(Ke)) || We--;
+              }
+              Ne = U.nextSibling();
+            }
+            ie = Ne && Be === ce ? U : null;
+          }
+          const ke = ce - D;
+          let Ge = Xe(ke);
+          const rt = ke - he;
+          let Je = null;
+          {
+            let Be, Re;
+            for (; Se && typeof (Be = P.getKey()) == "number"; ) {
+              Re = Be - be;
+              const ze = P.getComponent(), Ke = o(ze);
+              if (Re > rt)
+                break;
+              if (Re === rt) {
+                if (!Ke) {
+                  Je = P;
+                  break;
+                }
+                {
+                  if (A === 0 && Oe) {
+                    Je = P;
+                    break;
+                  }
+                  const Fe = Ge && O(Ge.getComponent());
+                  if (A === 0 && Fe)
+                    break;
+                }
+              }
+              if (Ke) {
+                const Fe = ze.d;
+                K[Fe], ze.i === void 0 && (g[Fe] || K[Fe] != null && A !== 1) ? (g[Fe] || K[Fe] != null && A === 0) && (be++, He--) : be++;
+              }
+              Se = P.nextSibling();
+            }
+          }
+          const Ot = rt + be + We + He;
+          l(Ot >= 0, "trying to descend to a negative index"), k.descend(Ot), Oe && (ie = Ge = Je = null, x++), Q(ie, B, Ge, Je, k, z) && He++, k.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 = Xe(S);
+          let ke;
+          for (; Se && (ke = P.getKey(), typeof ke != "string" || !(ke > S || ke === S)); )
+            Se = P.nextSibling();
+          const Ge = Se && ke === S ? P : null;
+          k.descend(S), Q(Oe, B, ce, Ge, k, z), k.ascend();
+        }
+      return Xe.end(), Ye && U.ascend(), je && P.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, P) => {
+      M.d != null && B(M.d, Q, P);
+    });
+    (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 = i.readCursor(tt(oe.get()));
+      if (Ue(Q, null, (U, B) => {
+        Ee[U] = B.clone();
+      }), te.forEach((U) => {
+        U && Ue(i.readCursor(U.get()), null, (B, M) => {
+          Ee[B] = M.clone();
+        });
+      }), function U(B, M, P, k, z, Y) {
+        const ee = a(M);
+        if (ee && O(ee))
+          if (ee.p != null) {
+            const D = ee.p;
+            Ee[D].getPath(), P = Ee[D], k = $e[D] = i.writeCursor();
+          } else
+            ee.r !== void 0 && (P = null);
+        else
+          o(a(P)) && (P = null);
+        const fe = B.getComponent();
+        if (fe) {
+          let D;
+          if ((D = fe.d) != null) {
+            const x = te[D];
+            x && (x.get(), k.mergeTree(x.get()), P = i.readCursor(x.get()));
+          }
+        }
+        let de = 0, le = 0;
+        const ye = i.advancer(M, void 0, (D, x) => {
+          O(x) && de--;
+        }), V = i.advancer(P, (D, x) => o(x) ? -(D - le) - 1 : D - le, (D, x) => {
+          o(x) && le++;
+        });
+        for (const D of B)
+          if (typeof D == "number") {
+            const x = ye(D), he = D + de, be = V(he), We = he + le;
+            k.descend(We), U(B, x, be, k), k.ascend();
+          } else
+            k.descend(D), U(B, ye(D), V(D), k), k.ascend();
+        ye.end(), V.end();
+      }(_e, Q, Q.clone(), oe), oe.reset(), m)
+        return {
+          ok: !1,
+          conflict: m
+        };
+      if (oe.get(), $e.length) {
+        const U = $e.map((M) => M ? M.get() : null), B = i.readCursor(tt(oe.get()));
+        if (Ue(B, oe, (M, P, k) => {
+          const z = U[M];
+          z && (k.mergeTree(z), U[M] = null);
+        }), U.find((M) => M)) {
+          const M = i.writeCursor(), P = i.writeCursor();
+          let k = 0, z = 0;
+          U.forEach((Y) => {
+            Y != null && Ue(i.readCursor(Y), null, (ee) => {
+              const fe = Le[ee];
+              M.writeMove(C[fe].getPath(), $[fe].getPath(), k++);
+              const de = se[fe];
+              de && de.forEach((le) => {
+                g[le] || A !== 1 && K[le] != null || P.writeMove(j[le].getPath(), p[le].getPath(), z++);
+              });
+            });
+          }), m = {
+            type: d.ConflictType.BLACKHOLE,
+            op1: M.get(),
+            op2: P.get()
+          };
+        }
+      }
+    }
+    return m ? {
+      ok: !1,
+      conflict: m
+    } : {
+      ok: !0,
+      result: oe.get()
+    };
+  }
+  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 A = nt(r, u, y);
+    if (A.ok)
+      return A.result;
+    gt(A.conflict);
+  }
+  const qe = (r) => {
+    const u = i.writeCursor();
+    return i.readCursor(r).traverse(u, (y, A) => {
+      (o(y) || ve(y)) && A.write("r", !0);
+    }), u.get();
+  }, Pt = (r, u) => {
+    const { type: y, op1: A, op2: m } = r;
+    switch (y) {
+      case d.ConflictType.DROP_COLLISION:
+        return u === "left" ? [null, qe(m)] : [qe(A), null];
+      case d.ConflictType.RM_UNEXPECTED_CONTENT:
+        let C = !1;
+        return i.readCursor(A).traverse(null, ($) => {
+          $.r !== void 0 && (C = !0);
+        }), C ? [null, qe(m)] : [qe(A), null];
+      case d.ConflictType.BLACKHOLE:
+        return [qe(A), qe(m)];
+      default:
+        throw Error("Unrecognised conflict: " + y);
+    }
+  };
+  function _t(r, u, y, A) {
+    let m = null;
+    for (; ; ) {
+      const C = nt(u, y, A);
+      if (C.ok)
+        return ne(m, C.result);
+      {
+        const { conflict: $ } = C;
+        r($) || gt($);
+        const [j, p] = Pt($, A);
+        u = ne(H(u), j), y = ne(H(y), p), m = ne(m, p);
+      }
+    }
+  }
+})(Ct);
+(function(t) {
+  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];
+    } });
+  } : function(d, l, a, E) {
+    E === void 0 && (E = a), d[E] = l[a];
+  }), n = Ce && Ce.__exportStar || function(d, l) {
+    for (var a in d)
+      a !== "default" && !l.hasOwnProperty(a) && e(l, d, a);
+  };
+  Object.defineProperty(t, "__esModule", { value: !0 }), n(Ct, t);
+  var s = ft;
+  Object.defineProperty(t, "ReadCursor", { enumerable: !0, get: function() {
+    return s.ReadCursor;
+  } }), Object.defineProperty(t, "WriteCursor", { enumerable: !0, get: function() {
+    return s.WriteCursor;
+  } });
+  var i = ht;
+  Object.defineProperty(t, "ConflictType", { enumerable: !0, get: function() {
+    return i.ConflictType;
+  } });
+})(F);
+class Ht {
+  constructor() {
+    q(this, "drawingManagerData", {});
+    q(this, "_oldDrawingManagerData", {});
+    q(this, "_focusDrawings", []);
+    q(this, "_remove$", new we());
+    q(this, "remove$", this._remove$.asObservable());
+    q(this, "_add$", new we());
+    q(this, "add$", this._add$.asObservable());
+    q(this, "_update$", new we());
+    q(this, "update$", this._update$.asObservable());
+    q(this, "_order$", new we());
+    q(this, "order$", this._order$.asObservable());
+    q(this, "_group$", new we());
+    q(this, "group$", this._group$.asObservable());
+    q(this, "_ungroup$", new we());
+    q(this, "ungroup$", this._ungroup$.asObservable());
+    q(this, "_refreshTransform$", new we());
+    q(this, "refreshTransform$", this._refreshTransform$.asObservable());
+    q(this, "_visible$", new we());
+    q(this, "visible$", this._visible$.asObservable());
+    // private readonly _externalUpdate$ = new Subject<T[]>();
+    // readonly externalUpdate$ = this._externalUpdate$.asObservable();
+    q(this, "_focus$", new we());
+    q(this, "focus$", this._focus$.asObservable());
+    q(this, "_featurePluginUpdate$", new we());
+    q(this, "featurePluginUpdate$", this._featurePluginUpdate$.asObservable());
+    q(this, "_featurePluginAdd$", new we());
+    q(this, "featurePluginAdd$", this._featurePluginAdd$.asObservable());
+    q(this, "_featurePluginRemove$", new we());
+    q(this, "featurePluginRemove$", this._featurePluginRemove$.asObservable());
+    q(this, "_featurePluginOrderUpdate$", new we());
+    q(this, "featurePluginOrderUpdate$", this._featurePluginOrderUpdate$.asObservable());
+    q(this, "_featurePluginGroupUpdate$", new we());
+    q(this, "featurePluginGroupUpdate$", this._featurePluginGroupUpdate$.asObservable());
+    q(this, "_featurePluginUngroupUpdate$", new we());
+    q(this, "featurePluginUngroupUpdate$", this._featurePluginUngroupUpdate$.asObservable());
+  }
+  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 = {};
+  }
+  visibleNotification(e) {
+    this._visible$.next(e);
+  }
+  refreshTransform(e) {
+    e.forEach((n) => {
+      if (this.getDrawingByParam(n) == null)
+        return;
+      const i = this._getCurrentBySearch(n);
+      i != null && (i.transform = n.transform);
+    }), this.refreshTransformNotification(e);
+  }
+  getDrawingDataForUnit(e) {
+    return this.drawingManagerData[e];
+  }
+  removeDrawingDataForUnit(e) {
+    const n = this.drawingManagerData[e];
+    if (n == null)
+      return;
+    delete this.drawingManagerData[e];
+    const s = [];
+    Object.keys(n).forEach((i) => {
+      const d = n[i];
+      (d == null ? void 0 : d.data) != null && Object.keys(d.data).forEach((l) => {
+        s.push({ unitId: e, subUnitId: i, drawingId: l });
+      });
+    }), s.length > 0 && this.removeNotification(s);
+  }
+  registerDrawingData(e, n) {
+    this.drawingManagerData[e] = n;
+    const s = [];
+    Object.keys(n).forEach((i) => {
+      this._establishDrawingMap(e, i);
+      const d = n[i];
+      Object.keys(d.data).forEach((l) => {
+        const a = d.data[l];
+        s.push(a);
+      });
+    }), s.length > 0 && this.addNotification(s);
+  }
+  getDrawingData(e, n) {
+    return this._getDrawingData(e, n);
+  }
+  getBatchAddOp(e) {
+    const n = [], s = [], i = [];
+    e.forEach((W) => {
+      const { op: O, invertOp: o } = this._addByParam(W);
+      n.push({ unitId: W.unitId, subUnitId: W.subUnitId, drawingId: W.drawingId }), s.push(O), i.push(o);
+    });
+    const d = s.reduce(F.type.compose, null), l = i.reduce(F.type.compose, null), { unitId: a, subUnitId: E } = e[0];
+    return { undo: l, redo: d, unitId: a, subUnitId: E, objects: n };
+  }
+  getBatchRemoveOp(e) {
+    const n = [], s = [];
+    e.forEach((E) => {
+      const { op: W, invertOp: O } = this._removeByParam(E);
+      n.push(W), s.push(O);
+    });
+    const i = n.reduce(F.type.compose, null), d = s.reduce(F.type.compose, null), { unitId: l, subUnitId: a } = e[0];
+    return { undo: d, redo: i, unitId: l, subUnitId: a, objects: e };
+  }
+  getBatchUpdateOp(e) {
+    const n = [], s = [], i = [];
+    e.forEach((W) => {
+      const { op: O, invertOp: o } = this._updateByParam(W);
+      n.push({ unitId: W.unitId, subUnitId: W.subUnitId, drawingId: W.drawingId }), s.push(O), i.push(o);
+    });
+    const d = s.reduce(F.type.compose, null), l = i.reduce(F.type.compose, null), { unitId: a, subUnitId: E } = e[0];
+    return { undo: l, redo: d, unitId: a, subUnitId: E, objects: n };
+  }
+  removeNotification(e) {
+    this._remove$.next(e);
+  }
+  addNotification(e) {
+    this._add$.next(e);
+  }
+  updateNotification(e) {
+    this._update$.next(e);
+  }
+  orderNotification(e) {
+    this._order$.next(e);
+  }
+  groupUpdateNotification(e) {
+    this._group$.next(e);
+  }
+  ungroupUpdateNotification(e) {
+    this._ungroup$.next(e);
+  }
+  refreshTransformNotification(e) {
+    this._refreshTransform$.next(e);
+  }
+  getGroupDrawingOp(e) {
+    const n = [], { unitId: s, subUnitId: i } = e[0].parent;
+    e.forEach((a) => {
+      n.push(this._getGroupDrawingOp(a));
+    });
+    const d = n.reduce(F.type.compose, null);
+    return { undo: F.type.invertWithDoc(d, this.drawingManagerData), redo: d, unitId: s, subUnitId: i, objects: e };
+  }
+  getUngroupDrawingOp(e) {
+    const n = [], { unitId: s, subUnitId: i } = e[0].parent;
+    e.forEach((a) => {
+      n.push(this._getUngroupDrawingOp(a));
+    });
+    const d = n.reduce(F.type.compose, null);
+    return { undo: F.type.invertWithDoc(d, this.drawingManagerData), redo: d, unitId: s, subUnitId: i, objects: e };
+  }
+  getDrawingsByGroup(e) {
+    const { unitId: n, subUnitId: s, drawingId: i } = e;
+    if (this.getDrawingByParam({ unitId: n, subUnitId: s, drawingId: i }) == null)
+      return [];
+    const l = this._getDrawingData(n, s), a = [];
+    return Object.keys(l).forEach((E) => {
+      const W = l[E];
+      W.groupId === i && a.push(W);
+    }), a;
+  }
+  _getGroupDrawingOp(e) {
+    const { parent: n, children: s } = e, { unitId: i, subUnitId: d, drawingId: l } = n, a = [];
+    a.push(
+      F.insertOp([i, d, "data", l], n)
+    );
+    let E = Number.NEGATIVE_INFINITY;
+    return s.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 }))
+      );
+    }), E === Number.NEGATIVE_INFINITY && (E = this._getDrawingOrder(i, d).length), a.push(
+      F.insertOp([i, d, "order", E], l)
+    ), a.reduce(F.type.compose, null);
+  }
+  _getUngroupDrawingOp(e) {
+    const { parent: n, children: s } = e, { unitId: i, subUnitId: d, drawingId: l } = n, a = [];
+    return s.forEach((E) => {
+      const { unitId: W, subUnitId: O, drawingId: o } = E;
+      a.push(
+        ...this._getUpdateParamCompareOp(E, this.getDrawingByParam({ unitId: W, subUnitId: O, drawingId: o }))
+      );
+    }), a.push(
+      F.removeOp([i, d, "data", l], !0)
+    ), a.push(
+      F.removeOp([i, d, "order", this._getDrawingOrder(i, d).indexOf(l)], !0)
+    ), a.reduce(F.type.compose, null);
+  }
+  applyJson1(e, n, s) {
+    this._establishDrawingMap(e, n), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = F.type.apply(this.drawingManagerData, s);
+  }
+  // private _fillMissingFields(jsonOp: JSONOp) {
+  //     if (jsonOp == null) {
+  //         return;
+  //     }
+  //     let object: { [key: string]: {} } = this.drawingManagerData;
+  //     for (let i = 0; i < jsonOp.length; i++) {
+  //         const op = jsonOp[i];
+  //         if (Array.isArray(op)) {
+  //             const opKey = op[0] as string;
+  //             if (!(opKey in object)) {
+  //                 object[opKey] = null as unknown as never;
+  //             }
+  //         } else if (typeof op === 'string') {
+  //             object = object[op];
+  //             if (object == null) {
+  //                 break;
+  //             }
+  //         }
+  //     }
+  // }
+  featurePluginUpdateNotification(e) {
+    this._featurePluginUpdate$.next(e);
+  }
+  featurePluginOrderUpdateNotification(e) {
+    this._featurePluginOrderUpdate$.next(e);
+  }
+  featurePluginAddNotification(e) {
+    this._featurePluginAdd$.next(e);
+  }
+  featurePluginRemoveNotification(e) {
+    this._featurePluginRemove$.next(e);
+  }
+  featurePluginGroupUpdateNotification(e) {
+    this._featurePluginGroupUpdate$.next(e);
+  }
+  featurePluginUngroupUpdateNotification(e) {
+    this._featurePluginUngroupUpdate$.next(e);
+  }
+  getDrawingByParam(e) {
+    return this._getCurrentBySearch(e);
+  }
+  getOldDrawingByParam(e) {
+    return this._getOldBySearch(e);
+  }
+  getDrawingOKey(e) {
+    const [n, s, i] = e.split("#-#");
+    return this._getCurrentBySearch({ unitId: n, subUnitId: s, drawingId: i });
+  }
+  focusDrawing(e) {
+    if (e == null) {
+      this._focusDrawings = [], this._focus$.next([]);
+      return;
+    }
+    const n = [];
+    e.forEach((s) => {
+      var E;
+      const { unitId: i, subUnitId: d, drawingId: l } = s, a = (E = this._getDrawingData(i, d)) == null ? void 0 : E[l];
+      a != null && n.push(a);
+    }), n.length > 0 && (this._focusDrawings = n, this._focus$.next(n));
+  }
+  getFocusDrawings() {
+    const e = [];
+    return this._focusDrawings.forEach((n) => {
+      var a;
+      const { unitId: s, subUnitId: i, drawingId: d } = n, l = (a = this._getDrawingData(s, i)) == null ? void 0 : a[d];
+      l != null && e.push(l);
+    }), e;
+  }
+  getDrawingOrder(e, n) {
+    return this._getDrawingOrder(e, n);
+  }
+  orderUpdateNotification(e) {
+    this._order$.next(e);
+  }
+  getForwardDrawingsOp(e) {
+    const { unitId: n, subUnitId: s, drawingIds: i } = e, d = [], l = this.getDrawingOrder(n, s), a = [...i];
+    i.forEach((O) => {
+      const o = this._hasDrawingOrder({ unitId: n, subUnitId: s, drawingId: O });
+      if (o === -1 || o === l.length - 1)
+        return;
+      const c = F.moveOp([n, s, "order", o], [n, s, "order", o + 1]);
+      d.push(c), a.includes(l[o + 1]) || a.push(l[o + 1]);
+    });
+    const E = d.reduce(F.type.compose, null);
+    return { undo: F.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: n, subUnitId: s, objects: { ...e, drawingIds: a } };
+  }
+  getBackwardDrawingOp(e) {
+    const { unitId: n, subUnitId: s, drawingIds: i } = e, d = [], l = this.getDrawingOrder(n, s), a = [...i];
+    i.forEach((O) => {
+      const o = this._hasDrawingOrder({ unitId: n, subUnitId: s, drawingId: O });
+      if (o === -1 || o === 0)
+        return;
+      const c = F.moveOp([n, s, "order", o], [n, s, "order", o - 1]);
+      d.push(c), a.includes(l[o - 1]) || a.push(l[o - 1]);
+    });
+    const E = d.reduce(F.type.compose, null);
+    return { undo: F.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: n, subUnitId: s, objects: { ...e, drawingIds: a } };
+  }
+  getFrontDrawingsOp(e) {
+    const { unitId: n, subUnitId: s, drawingIds: i } = e, d = this._getOrderFromSearchParams(n, s, i), l = [...i], a = this.getDrawingOrder(n, s), E = [];
+    d.forEach((o) => {
+      const { drawingId: c } = o, h = this._getDrawingCount(n, s) - 1, R = F.moveOp([n, s, "order", this._getDrawingOrder(n, s).indexOf(c)], [n, s, "order", h]);
+      E.push(R), l.includes(a[h]) || l.push(a[h]);
+    });
+    const W = E.reduce(F.type.compose, null);
+    return { undo: F.type.invertWithDoc(W, this.drawingManagerData), redo: W, unitId: n, subUnitId: s, objects: { ...e, drawingIds: l } };
+  }
+  getBackDrawingsOp(e) {
+    const { unitId: n, subUnitId: s, drawingIds: i } = e, d = this._getOrderFromSearchParams(n, s, i, !0), l = [...i], a = this.getDrawingOrder(n, s), E = [];
+    d.forEach((o) => {
+      const { drawingId: c } = o, h = F.moveOp([n, s, "order", this._getDrawingOrder(n, s).indexOf(c)], [n, s, "order", 0]);
+      E.push(h), l.includes(a[0]) || l.push(a[0]);
+    });
+    const W = E.reduce(F.type.compose, null);
+    return { undo: F.type.invertWithDoc(W, this.drawingManagerData), redo: W, unitId: n, subUnitId: s, objects: { ...e, drawingIds: l } };
+  }
+  _getDrawingCount(e, n) {
+    return this.getDrawingOrder(e, n).length || 0;
+  }
+  _getOrderFromSearchParams(e, n, s, i = !1) {
+    return s.map((d) => {
+      const l = this._hasDrawingOrder({ unitId: e, subUnitId: n, drawingId: d });
+      return { drawingId: d, zIndex: l };
+    }).sort(i === !1 ? Mt : Nt);
+  }
+  _hasDrawingOrder(e) {
+    if (e == null)
+      return -1;
+    const { unitId: n, subUnitId: s, drawingId: i } = e;
+    return this._establishDrawingMap(n, s), this._getDrawingOrder(n, s).indexOf(i);
+  }
+  _getCurrentBySearch(e) {
+    var d, l, a;
+    if (e == null)
+      return;
+    const { unitId: n, subUnitId: s, drawingId: i } = e;
+    return (a = (l = (d = this.drawingManagerData[n]) == null ? void 0 : d[s]) == null ? void 0 : l.data) == null ? void 0 : a[i];
+  }
+  _getOldBySearch(e) {
+    var d, l, a;
+    if (e == null)
+      return;
+    const { unitId: n, subUnitId: s, drawingId: i } = e;
+    return (a = (l = (d = this._oldDrawingManagerData[n]) == null ? void 0 : d[s]) == null ? void 0 : l.data) == null ? void 0 : a[i];
+  }
+  _establishDrawingMap(e, n, s) {
+    var i;
+    return this.drawingManagerData[e] || (this.drawingManagerData[e] = {}), this.drawingManagerData[e][n] || (this.drawingManagerData[e][n] = {
+      data: {},
+      order: []
+    }), s == null ? null : (i = this.drawingManagerData[e][n].data) == null ? void 0 : i[s];
+  }
+  _addByParam(e) {
+    const { unitId: n, subUnitId: s, drawingId: i } = e;
+    this._establishDrawingMap(n, s, i);
+    const d = F.insertOp([n, s, "data", i], e), l = F.insertOp([n, s, "order", this._getDrawingOrder(n, s).length], i), a = [d, l].reduce(F.type.compose, null), E = F.type.invertWithDoc(a, this.drawingManagerData);
+    return { op: a, invertOp: E };
+  }
+  _removeByParam(e) {
+    if (e == null)
+      return { op: [], invertOp: [] };
+    const { unitId: n, subUnitId: s, drawingId: i } = e;
+    if (this._establishDrawingMap(n, s, i) == null)
+      return { op: [], invertOp: [] };
+    const l = F.removeOp([n, s, "data", i], !0), a = F.removeOp([n, s, "order", this._getDrawingOrder(n, s).indexOf(i)], !0), E = [l, a].reduce(F.type.compose, null), W = F.type.invertWithDoc(E, this.drawingManagerData);
+    return { op: E, invertOp: W };
+  }
+  _updateByParam(e) {
+    const { unitId: n, subUnitId: s, drawingId: i } = e, d = this._establishDrawingMap(n, s, i);
+    if (d == 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 };
+  }
+  // private _initializeDrawingData(updateParam: T, oldParam: T) {
+  //     Object.keys(updateParam).forEach((key) => {
+  //         if (!(key in oldParam)) {
+  //             oldParam[key as keyof IDrawingParam] = null as unknown as never;
+  //         }
+  //     });
+  // }
+  _getUpdateParamCompareOp(e, n) {
+    const { unitId: s, subUnitId: i, drawingId: d } = e, l = [];
+    return Object.keys(e).forEach((a) => {
+      const E = e[a], W = n[a];
+      W !== E && l.push(
+        F.replaceOp([s, i, "data", d, a], W, E)
+      );
+    }), l;
+  }
+  _getDrawingData(e, n) {
+    var s, i;
+    return ((i = (s = this.drawingManagerData[e]) == null ? void 0 : s[n]) == null ? void 0 : i.data) || {};
+  }
+  _getDrawingOrder(e, n) {
+    var s, i;
+    return ((i = (s = this.drawingManagerData[e]) == null ? void 0 : s[n]) == null ? void 0 : i.order) || [];
+  }
+}
+class Kt extends Ht {
+}
+function cn(t) {
+  const { unitId: e, subUnitId: n, drawingId: s } = t;
+  return `${e}#-#${n}#-#${s}`;
+}
+const un = async (t) => new Promise((e, n) => {
+  const s = new Image();
+  s.src = t, s.onload = () => {
+    e({
+      width: s.width,
+      height: s.height,
+      image: s
+    });
+  }, s.onerror = (i) => {
+    n(i);
+  };
+});
+var et = /* @__PURE__ */ ((t) => (t.URL = "URL", t.UUID = "UUID", t.BASE64 = "BASE64", t))(et || {}), Ze = /* @__PURE__ */ ((t) => (t.SUCCUSS = "0", t.ERROR_EXCEED_SIZE = "1", t.ERROR_IMAGE_TYPE = "2", t.ERROR_UPLOAD_COUNT_LIMIT = "3", t.ERROR_IMAGE = "4", t))(Ze || {});
+const Ft = It("core.image-io.service");
+class Vt {
+  constructor() {
+    q(this, "_waitCount", 0);
+    q(this, "_change$", new we());
+    q(this, "change$", this._change$);
+    q(this, "_imageSourceCache", /* @__PURE__ */ new Map());
+  }
+  setWaitCount(e) {
+    this._waitCount = e, this._change$.next(e);
+  }
+  getImageSourceCache(e, n) {
+    if (n === et.BASE64) {
+      const s = new Image();
+      return s.src = e, s;
+    }
+    return this._imageSourceCache.get(e);
+  }
+  addImageSourceCache(e, n, s) {
+    n === et.BASE64 || s == null || this._imageSourceCache.set(e, s);
+  }
+  async getImage(e) {
+    return Promise.resolve(e);
+  }
+  async saveImage(e) {
+    return new Promise((n, s) => {
+      if (!Wt.includes(e.type)) {
+        s(new Error(Ze.ERROR_IMAGE_TYPE)), this._decreaseWaiting();
+        return;
+      }
+      if (e.size > $t) {
+        s(new Error(Ze.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
+        return;
+      }
+      const i = new FileReader();
+      i.readAsDataURL(e), i.onload = (d) => {
+        var E;
+        const l = (E = d.target) == null ? void 0 : E.result;
+        if (l == null) {
+          s(new Error(Ze.ERROR_IMAGE)), this._decreaseWaiting();
+          return;
+        }
+        const a = kt.generateRandomId(6);
+        n({
+          imageId: a,
+          imageSourceType: et.BASE64,
+          source: l,
+          base64Cache: l,
+          status: Ze.SUCCUSS
+        }), this._decreaseWaiting();
+      };
+    });
+  }
+  _decreaseWaiting() {
+    this._waitCount -= 1, this._change$.next(this._waitCount);
+  }
+}
+const dn = "__default_document_sub_component_id20231101__";
+var qt = /* @__PURE__ */ ((t) => (t[t.forward = 0] = "forward", t[t.backward = 1] = "backward", t[t.front = 2] = "front", t[t.back = 3] = "back", t))(qt || {}), Xt = /* @__PURE__ */ ((t) => (t[t.UNRECOGNIZED = -1] = "UNRECOGNIZED", t[t.DRAWING_IMAGE = 0] = "DRAWING_IMAGE", t[t.DRAWING_SHAPE = 1] = "DRAWING_SHAPE", t[t.DRAWING_CHART = 2] = "DRAWING_CHART", t[t.DRAWING_TABLE = 3] = "DRAWING_TABLE", t[t.DRAWING_SMART_ART = 4] = "DRAWING_SMART_ART", t[t.DRAWING_VIDEO = 5] = "DRAWING_VIDEO", t[t.DRAWING_GROUP = 6] = "DRAWING_GROUP", t[t.DRAWING_UNIT = 7] = "DRAWING_UNIT", t[t.DRAWING_DOM = 8] = "DRAWING_DOM", t))(Xt || {});
+const zt = It("univer.drawing-manager.service");
+var Yt = Object.defineProperty, Zt = Object.getOwnPropertyDescriptor, Jt = (t, e, n, s) => {
+  for (var i = s > 1 ? void 0 : s ? Zt(e, n) : e, d = t.length - 1, l; d >= 0; d--)
+    (l = t[d]) && (i = (s ? l(e, n, i) : l(i)) || i);
+  return s && i && Yt(e, n, i), i;
+}, Qt = (t, e) => (n, s) => e(n, s, t);
+const en = "DRAWING_PLUGIN";
+var ot;
+let wt = (ot = class extends Rt {
+  constructor(t, e) {
+    super(), this._config = t, this._injector = e;
+  }
+  onStarting(t) {
+    this._initDependencies(t);
+  }
+  _initDependencies(t) {
+    var s;
+    St([
+      [Ft, { useClass: Vt }],
+      [zt, { useClass: Kt }]
+    ], (s = this._config) == null ? void 0 : s.override).forEach((i) => t.add(i));
+  }
+}, q(ot, "pluginName", en), ot);
+wt = Jt([
+  Qt(1, jt(Tt))
+], wt);
+export {
+  qt as ArrangeTypeEnum,
+  dn as DEFAULT_DOCUMENT_SUB_COMPONENT_ID,
+  Wt as DRAWING_IMAGE_ALLOW_IMAGE_LIST,
+  $t as DRAWING_IMAGE_ALLOW_SIZE,
+  an as DRAWING_IMAGE_COUNT_LIMIT,
+  ln as DRAWING_IMAGE_HEIGHT_LIMIT,
+  on as DRAWING_IMAGE_WIDTH_LIMIT,
+  Kt as DrawingManagerService,
+  Xt as DrawingTypeEnum,
+  zt as IDrawingManagerService,
+  Ft as IImageIoService,
+  Vt as ImageIoService,
+  et as ImageSourceType,
+  Ze as ImageUploadStatusType,
+  Ht as UnitDrawingService,
+  wt as UniverDrawingPlugin,
+  cn as getDrawingShapeKeyByDrawingSearch,
+  un as getImageSize
+};