@univerjs/drawing 0.2.4 → 0.2.6

package/lib/es/index.js

@@ -1,116 +1,123 @@
-var Pt = Object.defineProperty;
-var Mt = (n, e, t) => e in n ? Pt(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 { Subject as we } from "rxjs";
-import { sortRules as Ut, sortRulesByDesc as Nt, Tools as kt, Plugin as Rt, mergeOverrideWithDependencies as St } from "@univerjs/core";
-import { createIdentifier as It, Inject as Tt, Injector as jt } 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(n, e) {
-  if (Array.isArray(e))
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { Subject } from "rxjs";
+import { sortRules, sortRulesByDesc, createIdentifier, Tools, Inject, Injector, Plugin, mergeOverrideWithDependencies } from "@univerjs/core";
+const DRAWING_IMAGE_WIDTH_LIMIT = 500, DRAWING_IMAGE_HEIGHT_LIMIT = 500, DRAWING_IMAGE_COUNT_LIMIT = 10, DRAWING_IMAGE_ALLOW_SIZE = 5 * 1024 * 1024, DRAWING_IMAGE_ALLOW_IMAGE_LIST = ["image/png", "image/jpeg", "image/jpg", "image/gif", "image/bmp"];
+var commonjsGlobal = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, dist$1 = {}, json1_release = {}, deepEqual$1 = {};
+Object.defineProperty(deepEqual$1, "__esModule", { value: !0 });
+function eqObj(a, b) {
+  if (Array.isArray(b))
     return !1;
-  for (let t in n)
-    if (!ut(n[t], e[t]))
+  for (let k in a)
+    if (!deepEqual(a[k], b[k]))
       return !1;
-  for (let t in e)
-    if (n[t] === void 0)
+  for (let k in b)
+    if (a[k] === void 0)
       return !1;
   return !0;
 }
-function Bt(n, e) {
-  if (!Array.isArray(e) || n.length !== e.length)
+__name(eqObj, "eqObj");
+function eqArr(a, b) {
+  if (!Array.isArray(b) || a.length !== b.length)
     return !1;
-  for (let t = 0; t < n.length; t++)
-    if (!ut(n[t], e[t]))
+  for (let i = 0; i < a.length; i++)
+    if (!deepEqual(a[i], b[i]))
       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) ? Bt(n, e) : Gt(n, e);
+__name(eqArr, "eqArr");
+function deepEqual(a, b) {
+  return a === b ? !0 : a === null || b === null || typeof a != "object" || typeof b != "object" ? !1 : Array.isArray(a) ? eqArr(a, b) : eqObj(a, b);
 }
-ct.default = ut;
-var dt = {};
-Object.defineProperty(dt, "__esModule", { value: !0 });
-function lt(n) {
-  if (n === null)
+__name(deepEqual, "deepEqual");
+deepEqual$1.default = deepEqual;
+var deepClone$1 = {};
+Object.defineProperty(deepClone$1, "__esModule", { value: !0 });
+function deepClone(old) {
+  if (old === 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;
+  if (Array.isArray(old))
+    return old.map(deepClone);
+  if (typeof old == "object") {
+    const o = {};
+    for (let k in old)
+      o[k] = deepClone(old[k]);
+    return o;
   } else
-    return n;
+    return old;
 }
-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) => (
+__name(deepClone, "deepClone");
+deepClone$1.default = deepClone;
+var cursor = {};
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: !0 }), exports.eachChildOf = exports.advancer = exports.readCursor = exports.writeCursor = exports.WriteCursor = exports.ReadCursor = exports.isValidPathItem = void 0;
+  function assert(pred, msg) {
+    if (!pred)
+      throw new Error(msg);
+  }
+  __name(assert, "assert");
+  const isObject = /* @__PURE__ */ __name((o) => o != null && typeof o == "object" && !Array.isArray(o), "isObject"), isGreaterKey = /* @__PURE__ */ __name((a, b) => (
     // 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]);
+    typeof a == typeof b ? a > b : typeof a == "string" && typeof b == "number"
+  ), "isGreaterKey");
+  function copyAll(c, w) {
+    for (let _k in c) {
+      const k = _k;
+      w.write(k, c[k]);
     }
   }
-  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;
+  __name(copyAll, "copyAll"), exports.isValidPathItem = (k) => typeof k == "number" || typeof k == "string" && k !== "__proto__";
+  const _Cursor = class _Cursor {
+    constructor(op = null) {
+      this.parents = [], this.indexes = [], this.lcIdx = -1, this.idx = -1, this.container = op;
     }
     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--);
+      assert(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) : (assert(this.idx > 0), this.idx--, isObject(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 -= t(c[R - 1]) ? 2 : 1;
-      return o;
+      const path = [];
+      let c = this.container, p = this.parents.length - 1, i = this.idx;
+      for (; i >= 0; )
+        path.unshift(c[i]), i === 0 ? (i = this.indexes[p * 2], c = this.parents[p--]) : i -= isObject(c[i - 1]) ? 2 : 1;
+      return path;
     }
-  }
-  class l extends d {
+  };
+  __name(_Cursor, "Cursor");
+  let Cursor = _Cursor;
+  const _ReadCursor = class _ReadCursor extends Cursor {
     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];
+      return assert(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;
+      let c;
+      return this.container && this.container.length > this.idx + 1 && isObject(c = this.container[this.idx + 1]) ? c : null;
     }
     descendFirst() {
-      let o = this.idx + 1;
-      if (!this.container || o >= this.container.length || t(this.container[o]) && o + 1 >= this.container.length)
+      let i = this.idx + 1;
+      if (!this.container || i >= this.container.length || isObject(this.container[i]) && i + 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;
+      isObject(this.container[i]) && i++;
+      const firstChild = this.container[i];
+      return Array.isArray(firstChild) ? (this.indexes.push(this.idx), this.parents.push(this.container), this.indexes.push(i), this.idx = 0, this.container = firstChild) : this.idx = i, !0;
     }
     nextSibling() {
-      if (e(this.parents.length === this.indexes.length / 2), this.idx > 0 || this.parents.length === 0)
+      if (assert(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);
+      const i = this.indexes[this.indexes.length - 1] + 1, c = this.parents[this.parents.length - 1];
+      return i >= c.length ? !1 : (assert(!isNaN(i)), this.indexes[this.indexes.length - 1] = i, this.container = c[i], !0);
     }
-    _init(o, c, h, R) {
-      this.container = o, this.idx = c, this.parents = h.slice(), this.indexes = R.slice();
+    _init(_container, _idx, _parents, _indexes) {
+      this.container = _container, this.idx = _idx, this.parents = _parents.slice(), this.indexes = _indexes.slice();
     }
     clone() {
-      const o = new l();
-      return o._init(this.container, this.idx, this.parents, this.indexes), o;
+      const c = new _ReadCursor();
+      return c._init(this.container, this.idx, this.parents, this.indexes), c;
     }
     *[Symbol.iterator]() {
       if (this.descendFirst()) {
@@ -123,49 +130,51 @@ var ft = {};
     // 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();
+    traverse(w, fn) {
+      const c = this.getComponent();
+      c && fn(c, w);
+      for (const key of this)
+        w && w.descend(key), this.traverse(w, fn), w && w.ascend();
     }
-    eachPick(o, c) {
-      this.traverse(o, (h, R) => {
-        h.p != null && c(h.p, R);
+    eachPick(w, fn) {
+      this.traverse(w, (c, w2) => {
+        c.p != null && fn(c.p, w2);
       });
     }
-    eachDrop(o, c) {
-      this.traverse(o, (h, R) => {
-        h.d != null && c(h.d, R);
+    eachDrop(w, fn) {
+      this.traverse(w, (c, w2) => {
+        c.d != null && fn(c.d, w2);
       });
     }
-  }
-  n.ReadCursor = l;
-  class a extends d {
-    constructor(o = null) {
-      super(o), this.pendingDescent = [], this._op = o;
+  };
+  __name(_ReadCursor, "ReadCursor");
+  let ReadCursor = _ReadCursor;
+  exports.ReadCursor = ReadCursor;
+  const _WriteCursor = class _WriteCursor extends Cursor {
+    constructor(op = null) {
+      super(op), this.pendingDescent = [], this._op = op;
     }
     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;
+      assert(this.parents.length === this.indexes.length / 2), this.container === null && (this._op = this.container = []);
+      for (let j = 0; j < this.pendingDescent.length; j++) {
+        const k = this.pendingDescent[j];
+        let i = this.idx + 1;
+        if (i < this.container.length && isObject(this.container[i]) && i++, assert(i === this.container.length || !isObject(this.container[i])), i === this.container.length)
+          this.container.push(k), this.idx = i;
+        else if (this.container[i] === k)
+          this.idx = i;
         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);
+          if (!Array.isArray(this.container[i])) {
+            const oldChild = this.container.splice(i, this.container.length - i);
+            this.container.push(oldChild), this.lcIdx > -1 && (this.lcIdx = i);
           }
-          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];
+          for (this.indexes.push(this.idx), this.parents.push(this.container), this.lcIdx !== -1 && (assert(isGreaterKey(k, this.container[this.lcIdx][0])), i = this.lcIdx + 1, this.lcIdx = -1); i < this.container.length && isGreaterKey(k, this.container[i][0]); )
+            i++;
+          if (this.indexes.push(i), this.idx = 0, i < this.container.length && this.container[i][0] === k)
+            this.container = this.container[i];
           else {
-            const R = [c];
-            this.container.splice(h, 0, R), this.container = R;
+            const child = [k];
+            this.container.splice(i, 0, child), this.container = child;
           }
         }
       }
@@ -179,437 +188,448 @@ var ft = {};
     // components.
     getComponent() {
       this.flushDescent();
-      const o = this.idx + 1;
-      if (o < this.container.length && t(this.container[o]))
-        return this.container[o];
+      const i = this.idx + 1;
+      if (i < this.container.length && isObject(this.container[i]))
+        return this.container[i];
       {
-        const c = {};
-        return this.container.splice(o, 0, c), c;
+        const component = {};
+        return this.container.splice(i, 0, component), component;
       }
     }
-    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;
+    write(key, value) {
+      const component = this.getComponent();
+      assert(component[key] == null || component[key] === value, "Internal consistency error: Overwritten component. File a bug"), component[key] = value;
     }
     get() {
       return this._op;
     }
-    descend(o) {
-      if (!n.isValidPathItem(o))
+    descend(key) {
+      if (!exports.isValidPathItem(key))
         throw Error("Invalid JSON key");
-      this.pendingDescent.push(o);
+      this.pendingDescent.push(key);
     }
-    descendPath(o) {
-      return this.pendingDescent.push(...o), this;
+    descendPath(path) {
+      return this.pendingDescent.push(...path), this;
     }
     ascend() {
       this.pendingDescent.length ? this.pendingDescent.pop() : super.ascend();
     }
-    mergeTree(o, c = s) {
-      if (o === null)
+    mergeTree(data, mergeFn = copyAll) {
+      if (data === null)
         return;
-      if (e(Array.isArray(o)), o === this._op)
+      if (assert(Array.isArray(data)), data === 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);
+      const _lcIdx = this.lcIdx, oldDepth = this.parents.length;
+      let depth = 0;
+      for (let i = 0; i < data.length; i++) {
+        const c = data[i];
+        typeof c == "string" || typeof c == "number" ? (depth++, this.descend(c)) : Array.isArray(c) ? this.mergeTree(c, mergeFn) : typeof c == "object" && mergeFn(c, this);
       }
-      for (; Z--; )
+      for (; depth--; )
         this.ascend();
-      this.lcIdx = this.parents.length === R ? h : -1;
+      this.lcIdx = this.parents.length === oldDepth ? _lcIdx : -1;
     }
-    at(o, c) {
-      this.descendPath(o), c(this);
-      for (let h = 0; h < o.length; h++)
+    at(path, fn) {
+      this.descendPath(path), fn(this);
+      for (let i = 0; i < path.length; i++)
         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;
+    writeAtPath(path, key, value) {
+      return this.at(path, () => this.write(key, value)), this.reset(), this;
     }
-    writeMove(o, c, h = 0) {
-      return this.writeAtPath(o, "p", h).writeAtPath(c, "d", h);
+    writeMove(path1, path2, slot = 0) {
+      return this.writeAtPath(path1, "p", slot).writeAtPath(path2, "d", slot);
     }
     getPath() {
-      const o = super.getPath();
-      return o.push(...this.pendingDescent), o;
+      const path = super.getPath();
+      return path.push(...this.pendingDescent), path;
     }
-  }
-  n.WriteCursor = a, n.writeCursor = () => new a(), n.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)), i(J, pe))
+  };
+  __name(_WriteCursor, "WriteCursor");
+  let WriteCursor = _WriteCursor;
+  exports.WriteCursor = WriteCursor, exports.writeCursor = () => new WriteCursor(), exports.readCursor = (op) => new ReadCursor(op);
+  function advancer(r, listMap, listAdv) {
+    let didDescend, valid;
+    valid = didDescend = r ? r.descendFirst() : !1;
+    function adv(ktarget) {
+      let k2_;
+      for (; valid; ) {
+        const k2 = k2_ = r.getKey();
+        if (ktarget != null) {
+          let skip = !1;
+          if (listMap && typeof k2 == "number" && (k2_ = listMap(k2, r.getComponent()), k2_ < 0 && (k2_ = ~k2_, skip = !0)), isGreaterKey(k2_, ktarget))
             return null;
-          if (J === pe && !xe)
-            return O;
+          if (k2_ === ktarget && !skip)
+            return r;
         }
-        c && typeof J == "number" && c(J, O.getComponent()), R = O.nextSibling();
+        listAdv && typeof k2_ == "number" && listAdv(k2_, r.getComponent()), valid = r.nextSibling();
       }
       return null;
     }
-    return Z.end = () => {
-      h && O.ascend();
-    }, Z;
-  }
-  n.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 && (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());
+    return __name(adv, "adv"), adv.end = () => {
+      didDescend && r.ascend();
+    }, adv;
+  }
+  __name(advancer, "advancer"), exports.advancer = advancer;
+  function eachChildOf(r1, r2, fn) {
+    let hasChild1, descended1, hasChild2, descended2;
+    for (hasChild1 = descended1 = r1 && r1.descendFirst(), hasChild2 = descended2 = r2 && r2.descendFirst(); hasChild1 || hasChild2; ) {
+      let k1 = hasChild1 ? r1.getKey() : null, k2 = hasChild2 ? r2.getKey() : null;
+      k1 !== null && k2 !== null && (isGreaterKey(k2, k1) ? k2 = null : k1 !== k2 && (k1 = null)), fn(k1 == null ? k2 : k1, k1 != null ? r1 : null, k2 != null ? r2 : null), k1 != null && hasChild1 && (hasChild1 = r1.nextSibling()), k2 != null && hasChild2 && (hasChild2 = r2.nextSibling());
     }
-    R && 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++);
+    descended1 && r1.ascend(), descended2 && r2.ascend();
+  }
+  __name(eachChildOf, "eachChildOf"), exports.eachChildOf = eachChildOf;
+})(cursor);
+var types = {};
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: !0 }), exports.ConflictType = void 0, function(ConflictType) {
+    ConflictType[ConflictType.RM_UNEXPECTED_CONTENT = 1] = "RM_UNEXPECTED_CONTENT", ConflictType[ConflictType.DROP_COLLISION = 2] = "DROP_COLLISION", ConflictType[ConflictType.BLACKHOLE = 3] = "BLACKHOLE";
+  }(exports.ConflictType || (exports.ConflictType = {}));
+})(types);
+var dist = {}, unicount = {}, hasRequiredUnicount;
+function requireUnicount() {
+  return hasRequiredUnicount || (hasRequiredUnicount = 1, Object.defineProperty(unicount, "__esModule", { value: !0 }), unicount.uniToStrPos = unicount.strPosToUni = void 0, unicount.strPosToUni = (s, strOffset = s.length) => {
+    let pairs = 0, i = 0;
+    for (; i < strOffset; i++) {
+      const code = s.charCodeAt(i);
+      code >= 55296 && code <= 57343 && (pairs++, i++);
     }
-    if (i !== e)
+    if (i !== strOffset)
       throw Error("Invalid offset - splits unicode bytes");
-    return i - t;
-  }, Fe.uniToStrPos = (n, e) => {
-    let t = 0;
-    for (; e > 0; e--) {
-      const i = n.charCodeAt(t);
-      t += i >= 55296 && i <= 57343 ? 2 : 1;
+    return i - pairs;
+  }, unicount.uniToStrPos = (s, uniOffset) => {
+    let pos = 0;
+    for (; uniOffset > 0; uniOffset--) {
+      const code = s.charCodeAt(pos);
+      pos += code >= 55296 && code <= 57343 ? 2 : 1;
     }
-    return t;
-  }), Fe;
+    return pos;
+  }), unicount;
 }
-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) => {
-      if (!Array.isArray(f))
+__name(requireUnicount, "requireUnicount");
+var type = {}, hasRequiredType;
+function requireType() {
+  return hasRequiredType || (hasRequiredType = 1, function(exports) {
+    Object.defineProperty(exports, "__esModule", { value: !0 }), exports.uniSlice = exports.dlen = exports.eachOp = void 0;
+    const unicount_1 = requireUnicount(), checkOp = /* @__PURE__ */ __name((op) => {
+      if (!Array.isArray(op))
         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) {
+      let last = null;
+      for (let i = 0; i < op.length; i++) {
+        const c = op[i];
+        switch (typeof c) {
           case "object":
-            if (typeof L.d != "number" && typeof L.d != "string")
+            if (typeof c.d != "number" && typeof c.d != "string")
               throw Error("Delete must be number or string");
-            if (n.dlen(L.d) <= 0)
+            if (exports.dlen(c.d) <= 0)
               throw Error("Deletes must not be empty");
             break;
           case "string":
-            if (!(L.length > 0))
+            if (!(c.length > 0))
               throw Error("Inserts cannot be empty");
             break;
           case "number":
-            if (!(L > 0))
+            if (!(c > 0))
               throw Error("Skip components must be >0");
-            if (typeof _ == "number")
+            if (typeof last == "number")
               throw Error("Adjacent skip components should be combined");
             break;
         }
-        _ = L;
+        last = c;
       }
-      if (typeof _ == "number")
+      if (typeof last == "number")
         throw Error("Op has a trailing skip");
-    };
-    function i(f, _) {
-      let w = 0, L = 0;
-      for (let z = 0; z < f.length; z++) {
-        const H = f[z];
-        switch (_(H, w, L), typeof H) {
+    }, "checkOp");
+    function eachOp(op, fn) {
+      let prePos = 0, postPos = 0;
+      for (let i = 0; i < op.length; i++) {
+        const c = op[i];
+        switch (fn(c, prePos, postPos), typeof c) {
           case "object":
-            w += n.dlen(H.d);
+            prePos += exports.dlen(c.d);
             break;
           case "string":
-            L += e.strPosToUni(H);
+            postPos += unicount_1.strPosToUni(c);
             break;
           case "number":
-            w += H, L += H;
+            prePos += c, postPos += c;
             break;
         }
       }
     }
-    n.eachOp = i;
-    function s(f, _) {
-      const w = [], L = a(w);
-      return i(f, (z, H, De) => {
-        L(_(z, H, De));
-      }), o(w);
+    __name(eachOp, "eachOp"), exports.eachOp = eachOp;
+    function mapOp(op, fn) {
+      const newOp = [], append = makeAppend(newOp);
+      return eachOp(op, (c, prePos, postPos) => {
+        append(fn(c, prePos, postPos));
+      }), trim(newOp);
     }
-    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);
+    __name(mapOp, "mapOp");
+    const id = /* @__PURE__ */ __name((x) => x, "id"), normalize = /* @__PURE__ */ __name((op) => mapOp(op, id), "normalize");
+    exports.dlen = (d) => typeof d == "number" ? d : unicount_1.strPosToUni(d);
+    const makeAppend = /* @__PURE__ */ __name((op) => (component) => {
+      if (!(!component || component.d === 0 || component.d === "")) if (op.length === 0)
+        op.push(component);
+      else if (typeof component == typeof op[op.length - 1])
+        if (typeof component == "object") {
+          const last = op[op.length - 1];
+          last.d = typeof last.d == "string" && typeof component.d == "string" ? last.d + component.d : exports.dlen(last.d) + exports.dlen(component.d);
         } else
-          f[f.length - 1] += _;
+          op[op.length - 1] += component;
       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);
-    n.uniSlice = (f, _, w) => {
-      const L = e.uniToStrPos(f, _), z = w == null ? 1 / 0 : e.uniToStrPos(f, w);
-      return f.slice(L, z);
+        op.push(component);
+    }, "makeAppend"), componentLength = /* @__PURE__ */ __name((c) => typeof c == "number" ? c : typeof c == "string" ? unicount_1.strPosToUni(c) : typeof c.d == "number" ? c.d : unicount_1.strPosToUni(c.d), "componentLength");
+    exports.uniSlice = (s, startUni, endUni) => {
+      const start = unicount_1.uniToStrPos(s, startUni), end = endUni == null ? 1 / 0 : unicount_1.uniToStrPos(s, endUni);
+      return s.slice(start, end);
     };
-    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[_];
-        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;
+    const dslice = /* @__PURE__ */ __name((d, start, end) => typeof d == "number" ? end == null ? d - start : Math.min(d, end) - start : exports.uniSlice(d, start, end), "dslice"), makeTake = /* @__PURE__ */ __name((op) => {
+      let idx = 0, offset = 0;
+      return { take: /* @__PURE__ */ __name((n, indivisableField) => {
+        if (idx === op.length)
+          return n === -1 ? null : n;
+        const c = op[idx];
+        let part;
+        if (typeof c == "number")
+          return n === -1 || c - offset <= n ? (part = c - offset, ++idx, offset = 0, part) : (offset += n, n);
+        if (typeof c == "string") {
+          if (n === -1 || indivisableField === "i" || unicount_1.strPosToUni(c.slice(offset)) <= n)
+            return part = c.slice(offset), ++idx, offset = 0, part;
           {
-            const ae = w + e.uniToStrPos(ue.slice(w), H);
-            return ne = ue.slice(w, ae), w = ae, ne;
+            const offset2 = offset + unicount_1.uniToStrPos(c.slice(offset), n);
+            return part = c.slice(offset, offset2), offset = offset2, part;
           }
         } else {
-          if (H === -1 || De === "d" || n.dlen(ue.d) - w <= H)
-            return ne = { d: W(ue.d, w) }, ++_, w = 0, ne;
+          if (n === -1 || indivisableField === "d" || exports.dlen(c.d) - offset <= n)
+            return part = { d: dslice(c.d, offset) }, ++idx, offset = 0, part;
           {
-            let ae = W(ue.d, w, w + H);
-            return w += H, { d: ae };
+            let result = dslice(c.d, offset, offset + n);
+            return offset += n, { d: result };
           }
         }
-      }, 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) {
+      }, "take"), peek: /* @__PURE__ */ __name(() => op[idx], "peek") };
+    }, "makeTake"), trim = /* @__PURE__ */ __name((op) => (op.length > 0 && typeof op[op.length - 1] == "number" && op.pop(), op), "trim");
+    function transform(op1, op2, side) {
+      if (side !== "left" && side !== "right")
+        throw Error("side (" + side + ") must be 'left' or 'right'");
+      checkOp(op1), checkOp(op2);
+      const newOp = [], append = makeAppend(newOp), { take, peek } = makeTake(op1);
+      for (let i = 0; i < op2.length; i++) {
+        const c2 = op2[i];
+        let length, c1;
+        switch (typeof c2) {
           case "number":
-            for (ge = ae; ge > 0; )
-              Ae = H(ge, "i"), z(Ae), typeof Ae != "string" && (ge -= E(Ae));
+            for (length = c2; length > 0; )
+              c1 = take(length, "i"), append(c1), typeof c1 != "string" && (length -= componentLength(c1));
             break;
           case "string":
-            w === "left" && typeof De() == "string" && z(H(-1)), z(e.strPosToUni(ae));
+            side === "left" && typeof peek() == "string" && append(take(-1)), append(unicount_1.strPosToUni(c2));
             break;
           case "object":
-            for (ge = n.dlen(ae.d); ge > 0; )
-              switch (Ae = H(ge, "i"), typeof Ae) {
+            for (length = exports.dlen(c2.d); length > 0; )
+              switch (c1 = take(length, "i"), typeof c1) {
                 case "number":
-                  ge -= Ae;
+                  length -= c1;
                   break;
                 case "string":
-                  z(Ae);
+                  append(c1);
                   break;
                 case "object":
-                  ge -= n.dlen(Ae.d);
+                  length -= exports.dlen(c1.d);
               }
             break;
         }
       }
-      let ue;
-      for (; ue = H(-1); )
-        z(ue);
-      return o(L);
+      let c;
+      for (; c = take(-1); )
+        append(c);
+      return trim(newOp);
     }
-    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) {
+    __name(transform, "transform");
+    function compose(op1, op2) {
+      checkOp(op1), checkOp(op2);
+      const result = [], append = makeAppend(result), { take } = makeTake(op1);
+      for (let i = 0; i < op2.length; i++) {
+        const component = op2[i];
+        let length, chunk;
+        switch (typeof component) {
           case "number":
-            for (ne = ue; ne > 0; )
-              ae = z(ne, "d"), L(ae), typeof ae != "object" && (ne -= E(ae));
+            for (length = component; length > 0; )
+              chunk = take(length, "d"), append(chunk), typeof chunk != "object" && (length -= componentLength(chunk));
             break;
           case "string":
-            L(ue);
+            append(component);
             break;
           case "object":
-            ne = n.dlen(ue.d);
-            let ge = 0;
-            for (; ge < ne; )
-              switch (ae = z(ne - ge, "d"), typeof ae) {
+            length = exports.dlen(component.d);
+            let offset = 0;
+            for (; offset < length; )
+              switch (chunk = take(length - offset, "d"), typeof chunk) {
                 case "number":
-                  L({ d: W(ue.d, ge, ge + ae) }), ge += ae;
+                  append({ d: dslice(component.d, offset, offset + chunk) }), offset += chunk;
                   break;
                 case "string":
-                  ge += e.strPosToUni(ae);
+                  offset += unicount_1.strPosToUni(chunk);
                   break;
                 case "object":
-                  L(ae);
+                  append(chunk);
               }
             break;
         }
       }
-      let H;
-      for (; H = z(-1); )
-        L(H);
-      return o(w);
+      let c;
+      for (; c = take(-1); )
+        append(c);
+      return trim(result);
     }
-    const R = (f, _) => {
-      let w = 0;
-      for (let L = 0; L < _.length && f > w; L++) {
-        const z = _[L];
-        switch (typeof z) {
+    __name(compose, "compose");
+    const transformPosition = /* @__PURE__ */ __name((cursor2, op) => {
+      let pos = 0;
+      for (let i = 0; i < op.length && cursor2 > pos; i++) {
+        const c = op[i];
+        switch (typeof c) {
           case "number": {
-            w += z;
+            pos += c;
             break;
           }
           case "string":
-            const H = e.strPosToUni(z);
-            w += H, f += H;
+            const offset = unicount_1.strPosToUni(c);
+            pos += offset, cursor2 += offset;
             break;
           case "object":
-            f -= Math.min(n.dlen(z.d), f - w);
+            cursor2 -= Math.min(exports.dlen(c.d), cursor2 - pos);
             break;
         }
       }
-      return f;
-    }, Z = (f, _) => typeof f == "number" ? R(f, _) : f.map((w) => R(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);
+      return cursor2;
+    }, "transformPosition"), transformSelection = /* @__PURE__ */ __name((selection, op) => typeof selection == "number" ? transformPosition(selection, op) : selection.map((s) => transformPosition(s, op)), "transformSelection");
+    function makeInvertible(op, doc, ropeImpl) {
+      return mapOp(op, (c, prePos) => typeof c == "object" && typeof c.d == "number" ? { d: ropeImpl.slice(doc, prePos, prePos + c.d) } : c);
     }
-    function J(f) {
-      return s(f, (_) => {
-        switch (typeof _) {
+    __name(makeInvertible, "makeInvertible");
+    function invert(op) {
+      return mapOp(op, (c) => {
+        switch (typeof c) {
           case "object":
-            if (typeof _.d == "number")
+            if (typeof c.d == "number")
               throw Error("Cannot invert text op: Deleted characters missing from operation. makeInvertible must be called first.");
-            return _.d;
+            return c.d;
           case "string":
-            return { d: _ };
+            return { d: c };
           case "number":
-            return _;
+            return c;
         }
       });
     }
-    function Ie(f) {
-      return s(f, (_) => typeof _ == "object" && typeof _.d == "string" ? { d: e.strPosToUni(_.d) } : _);
+    __name(invert, "invert");
+    function stripInvertible(op) {
+      return mapOp(op, (c) => typeof c == "object" && typeof c.d == "string" ? { d: unicount_1.strPosToUni(c.d) } : c);
     }
-    function xe(f) {
-      let _ = !0;
-      return i(f, (w) => {
-        typeof w == "object" && typeof w.d == "number" && (_ = !1);
-      }), _;
+    __name(stripInvertible, "stripInvertible");
+    function isInvertible(op) {
+      let invertible = !0;
+      return eachOp(op, (c) => {
+        typeof c == "object" && typeof c.d == "number" && (invertible = !1);
+      }), invertible;
     }
-    function ve(f) {
+    __name(isInvertible, "isInvertible");
+    function makeType(ropeImpl) {
       return {
         name: "text-unicode",
         uri: "http://sharejs.org/types/text-unicode",
-        trim: o,
-        normalize: l,
-        checkOp: t,
+        trim,
+        normalize,
+        checkOp,
         /** 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(initial = "") {
+          if (typeof initial != "string")
             throw Error("Initial data must be a string");
-          return f.create(_);
+          return ropeImpl.create(initial);
         },
         /** 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(str, op) {
+          checkOp(op);
+          const builder = ropeImpl.builder(str);
+          for (let i = 0; i < op.length; i++) {
+            const component = op[i];
+            switch (typeof component) {
               case "number":
-                L.skip(H);
+                builder.skip(component);
                 break;
               case "string":
-                L.append(H);
+                builder.append(component);
                 break;
               case "object":
-                L.del(n.dlen(H.d));
+                builder.del(exports.dlen(component.d));
                 break;
             }
           }
-          return L.build();
+          return builder.build();
         },
-        transform: c,
-        compose: h,
-        transformPosition: R,
-        transformSelection: Z,
-        isInvertible: xe,
-        makeInvertible(_, w) {
-          return pe(_, w, f);
+        transform,
+        compose,
+        transformPosition,
+        transformSelection,
+        isInvertible,
+        makeInvertible(op, doc) {
+          return makeInvertible(op, doc, ropeImpl);
         },
-        stripInvertible: Ie,
-        invert: J,
-        invertWithDoc(_, w) {
-          return J(pe(_, w, f));
+        stripInvertible,
+        invert,
+        invertWithDoc(op, doc) {
+          return invert(makeInvertible(op, doc, ropeImpl));
         },
-        isNoop: (_) => _.length === 0
+        isNoop: /* @__PURE__ */ __name((op) => op.length === 0, "isNoop")
       };
     }
-    n.default = ve;
-  }(st)), st;
+    __name(makeType, "makeType"), exports.default = makeType;
+  }(type)), type;
 }
-var Qe = {}, mt;
-function xt() {
-  if (mt) return Qe;
-  mt = 1, Object.defineProperty(Qe, "__esModule", { value: !0 });
-  const n = at(), e = pt();
-  function t(i, s) {
+__name(requireType, "requireType");
+var api = {}, hasRequiredApi;
+function requireApi() {
+  if (hasRequiredApi) return api;
+  hasRequiredApi = 1, Object.defineProperty(api, "__esModule", { value: !0 });
+  const type_1 = requireType(), unicount_1 = requireUnicount();
+  function api$1(getSnapshot, submitOp) {
     return {
       // Returns the text content of the document
-      get: i,
+      get: getSnapshot,
       // Returns the number of characters in the string
       getLength() {
-        return i().length;
+        return getSnapshot().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(pos, text, callback) {
+        const uniPos = unicount_1.strPosToUni(getSnapshot(), pos);
+        return submitOp([uniPos, text], callback);
       },
-      remove(d, l, a) {
-        const E = e.strPosToUni(i(), d);
-        return s([E, { d: l }], a);
+      remove(pos, lengthOrContent, callback) {
+        const uniPos = unicount_1.strPosToUni(getSnapshot(), pos);
+        return submitOp([uniPos, { d: lengthOrContent }], callback);
       },
       // 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(op) {
+        type_1.eachOp(op, (component, prePos, postPos) => {
+          switch (typeof component) {
             case "string":
-              this.onInsert && this.onInsert(E, l);
+              this.onInsert && this.onInsert(postPos, component);
               break;
             case "object":
-              const W = n.dlen(l.d);
-              this.onRemove && this.onRemove(E, W);
+              const dl = type_1.dlen(component.d);
+              this.onRemove && this.onRemove(postPos, dl);
           }
         });
       },
@@ -617,1044 +637,1062 @@ function xt() {
       onRemove: null
     };
   }
-  return Qe.default = t, t.provides = { text: !0 }, Qe;
+  return __name(api$1, "api$1"), api.default = api$1, api$1.provides = { text: !0 }, api;
 }
-var bt;
-function Lt() {
-  return bt || (bt = 1, function(n) {
-    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];
-    }), t = Ce && Ce.__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) {
-      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 t(h, c), h;
-    }, s = Ce && Ce.__importDefault || function(c) {
-      return c && c.__esModule ? c : { default: c };
+__name(requireApi, "requireApi");
+var hasRequiredDist;
+function requireDist() {
+  return hasRequiredDist || (hasRequiredDist = 1, function(exports) {
+    var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+      k2 === void 0 && (k2 = k), Object.defineProperty(o, k2, { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+        return m[k];
+      }, "get") });
+    } : function(o, m, k, k2) {
+      k2 === void 0 && (k2 = k), o[k2] = m[k];
+    }), __setModuleDefault = commonjsGlobal && commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: !0, value: v });
+    } : function(o, v) {
+      o.default = v;
+    }), __importStar = commonjsGlobal && commonjsGlobal.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) for (var k in mod) Object.hasOwnProperty.call(mod, k) && __createBinding(result, mod, k);
+      return __setModuleDefault(result, mod), result;
+    }, __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
     };
-    Object.defineProperty(n, "__esModule", { value: !0 }), n.type = n.remove = n.insert = void 0;
-    const d = pt(), l = i(at()), a = s(xt()), E = {
-      create(c) {
-        return c;
+    Object.defineProperty(exports, "__esModule", { value: !0 }), exports.type = exports.remove = exports.insert = void 0;
+    const unicount_1 = requireUnicount(), type_1 = __importStar(requireType()), api_1 = __importDefault(requireApi()), ropeImplUnicodeString = {
+      create(s) {
+        return s;
       },
-      toString(c) {
-        return c;
+      toString(s) {
+        return s;
       },
-      builder(c) {
-        if (typeof c != "string")
-          throw Error("Invalid document snapshot: " + c);
-        const h = [];
+      builder(oldDoc) {
+        if (typeof oldDoc != "string")
+          throw Error("Invalid document snapshot: " + oldDoc);
+        const newDoc = [];
         return {
-          skip(R) {
-            let Z = d.uniToStrPos(c, R);
-            if (Z > c.length)
+          skip(n) {
+            let offset = unicount_1.uniToStrPos(oldDoc, n);
+            if (offset > oldDoc.length)
               throw Error("The op is too long for this document");
-            h.push(c.slice(0, Z)), c = c.slice(Z);
+            newDoc.push(oldDoc.slice(0, offset)), oldDoc = oldDoc.slice(offset);
           },
-          append(R) {
-            h.push(R);
+          append(s) {
+            newDoc.push(s);
           },
-          del(R) {
-            c = c.slice(d.uniToStrPos(c, R));
+          del(n) {
+            oldDoc = oldDoc.slice(unicount_1.uniToStrPos(oldDoc, n));
           },
           build() {
-            return h.join("") + c;
+            return newDoc.join("") + oldDoc;
           }
         };
       },
-      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;
-    } });
-  }(it)), it;
+      slice: type_1.uniSlice
+    }, textString = type_1.default(ropeImplUnicodeString), type2 = Object.assign(Object.assign({}, textString), { api: api_1.default });
+    exports.type = type2, exports.insert = (pos, text) => text.length === 0 ? [] : pos === 0 ? [text] : [pos, text], exports.remove = (pos, textOrLen) => type_1.dlen(textOrLen) === 0 ? [] : pos === 0 ? [{ d: textOrLen }] : [pos, { d: textOrLen }];
+    var type_2 = requireType();
+    Object.defineProperty(exports, "makeType", { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+      return type_2.default;
+    }, "get") });
+  }(dist)), dist;
 }
-(function(n) {
-  var e = Ce && Ce.__importDefault || function(r) {
-    return r && r.__esModule ? r : {
-      default: r
+__name(requireDist, "requireDist");
+(function(exports) {
+  var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : {
+      default: mod
     };
   };
-  Object.defineProperty(n, "__esModule", {
+  Object.defineProperty(exports, "__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);
+  }), exports.editOp = exports.replaceOp = exports.insertOp = exports.moveOp = exports.removeOp = exports.type = void 0;
+  const deepEqual_js_1 = __importDefault(deepEqual$1), deepClone_js_1 = __importDefault(deepClone$1), cursor_js_1 = cursor, types_js_1 = types;
+  function assert(pred, msg) {
+    if (!pred) throw new Error(msg);
   }
-  n.type = {
+  __name(assert, "assert"), exports.type = {
     name: "json1",
     uri: "http://sharejs.org/types/JSONv1",
-    readCursor: s.readCursor,
-    writeCursor: s.writeCursor,
-    create: (r) => r,
-    isNoop: (r) => r == null,
-    setDebug(r) {
+    readCursor: cursor_js_1.readCursor,
+    writeCursor: cursor_js_1.writeCursor,
+    create: /* @__PURE__ */ __name((data) => data, "create"),
+    isNoop: /* @__PURE__ */ __name((op) => op == null, "isNoop"),
+    setDebug(val) {
     },
-    registerSubtype: J,
-    checkValidOp: z,
-    normalize: H,
-    apply: De,
-    transformPosition: ue,
-    compose: ne,
-    tryTransform: nt,
-    transform: Dt,
-    makeInvertible: Ae,
-    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({}, 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 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);
+    registerSubtype,
+    checkValidOp,
+    normalize,
+    apply,
+    transformPosition,
+    compose,
+    tryTransform,
+    transform,
+    makeInvertible,
+    invert,
+    invertWithDoc,
+    RM_UNEXPECTED_CONTENT: types_js_1.ConflictType.RM_UNEXPECTED_CONTENT,
+    DROP_COLLISION: types_js_1.ConflictType.DROP_COLLISION,
+    BLACKHOLE: types_js_1.ConflictType.BLACKHOLE,
+    transformNoConflict: /* @__PURE__ */ __name((op1, op2, side) => transformWithConflictsPred(() => !0, op1, op2, side), "transformNoConflict"),
+    typeAllowingConflictsPred: /* @__PURE__ */ __name((allowConflict) => Object.assign(Object.assign({}, exports.type), {
+      transform: /* @__PURE__ */ __name((op1, op2, side) => transformWithConflictsPred(allowConflict, op1, op2, side), "transform")
+    }), "typeAllowingConflictsPred")
   };
-  J(Lt());
-  const xe = (r, u) => r + u;
-  J({
+  const getComponent = /* @__PURE__ */ __name((r) => r ? r.getComponent() : null, "getComponent");
+  function isObject(o) {
+    return o && typeof o == "object" && !Array.isArray(o);
+  }
+  __name(isObject, "isObject");
+  const shallowClone = /* @__PURE__ */ __name((obj) => Array.isArray(obj) ? obj.slice() : obj !== null && typeof obj == "object" ? Object.assign({}, obj) : obj, "shallowClone"), hasPick = /* @__PURE__ */ __name((c) => c && (c.p != null || c.r !== void 0), "hasPick"), hasDrop = /* @__PURE__ */ __name((c) => c && (c.d != null || c.i !== void 0), "hasDrop");
+  function removeChild(container, key) {
+    return assert(container != null), typeof key == "number" ? (assert(Array.isArray(container), "Invalid key - child is not an array"), (container = container.slice()).splice(key, 1)) : (assert(isObject(container), "Invalid key - child is not an object"), delete (container = Object.assign({}, container))[key]), container;
+  }
+  __name(removeChild, "removeChild");
+  function insertChildMut(container, key, value) {
+    return typeof key == "number" ? (assert(container != null, "Container is missing for key"), assert(Array.isArray(container), "Cannot use numerical key for object container"), assert(container.length >= key, "Cannot insert into out of bounds index"), container.splice(key, 0, value)) : (assert(isObject(container), "Cannot insert into missing item"), assert(container[key] === void 0, "Trying to overwrite value at key. Your op needs to remove it first"), container[key] = value), value;
+  }
+  __name(insertChildMut, "insertChildMut"), exports.removeOp = (path, value = !0) => cursor_js_1.writeCursor().writeAtPath(path, "r", value).get(), exports.moveOp = (from, to) => cursor_js_1.writeCursor().writeMove(from, to).get(), exports.insertOp = (path, value) => cursor_js_1.writeCursor().writeAtPath(path, "i", value).get(), exports.replaceOp = (path, oldVal, newVal) => cursor_js_1.writeCursor().at(path, (w) => {
+    w.write("r", oldVal), w.write("i", newVal);
+  }).get(), exports.editOp = (path, type2, subOp, preserveNoop = !1) => cursor_js_1.writeCursor().at(path, (w) => writeEdit(w, type2, subOp, preserveNoop)).get();
+  const isValidKey = /* @__PURE__ */ __name((container, key) => container != null && (typeof key == "number" ? Array.isArray(container) : typeof container == "object"), "isValidKey"), maybeGetChild = /* @__PURE__ */ __name((container, key) => isValidKey(container, key) ? container[key] : void 0, "maybeGetChild"), subtypes = {};
+  function registerSubtype(subtype) {
+    let _subtype = subtype.type ? subtype.type : subtype;
+    _subtype.name && (subtypes[_subtype.name] = _subtype), _subtype.uri && (subtypes[_subtype.uri] = _subtype);
+  }
+  __name(registerSubtype, "registerSubtype");
+  const typeOrThrow = /* @__PURE__ */ __name((name) => {
+    const type2 = subtypes[name];
+    if (type2) return type2;
+    throw Error("Missing type: " + name);
+  }, "typeOrThrow");
+  registerSubtype(requireDist());
+  const add = /* @__PURE__ */ __name((a, b) => a + b, "add");
+  registerSubtype({
     name: "number",
-    apply: xe,
-    compose: xe,
-    invert: (r) => -r,
-    transform: (r) => r
+    apply: add,
+    compose: add,
+    invert: /* @__PURE__ */ __name((n) => -n, "invert"),
+    transform: /* @__PURE__ */ __name((a) => a, "transform")
   });
-  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, T = !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(!T), T = !0;
-          const b = ve(C);
-          l(b, "Missing type in edit"), b.checkValidOp && b.checkValidOp(f(C));
+  const getEditType = /* @__PURE__ */ __name((c) => c == null ? null : c.et ? typeOrThrow(c.et) : c.es ? subtypes["text-unicode"] : c.ena != null ? subtypes.number : null, "getEditType"), getEdit = /* @__PURE__ */ __name((c) => c.es ? c.es : c.ena != null ? c.ena : c.e, "getEdit"), writeEdit = /* @__PURE__ */ __name((w, typeOrName, edit, preserveNoop = !1) => {
+    const [type2, name] = typeof typeOrName == "string" ? [typeOrThrow(typeOrName), typeOrName] : [typeOrName, typeOrName.name];
+    !preserveNoop && type2.isNoop && type2.isNoop(edit) || (name === "number" ? w.write("ena", edit) : name === "text-unicode" ? w.write("es", edit) : (w.write("et", name), w.write("e", edit)));
+  }, "writeEdit");
+  function checkNonNegInteger(n) {
+    assert(typeof n == "number"), assert(n >= 0), assert(n === (0 | n));
+  }
+  __name(checkNonNegInteger, "checkNonNegInteger");
+  function checkScalar(s) {
+    typeof s == "number" ? checkNonNegInteger(s) : assert(typeof s == "string");
+  }
+  __name(checkScalar, "checkScalar");
+  function checkValidOp(op) {
+    if (op === null) return;
+    const pickedSlots = /* @__PURE__ */ new Set(), droppedSlots = /* @__PURE__ */ new Set(), checkComponent = /* @__PURE__ */ __name((e) => {
+      let empty = !0, hasEdit = !1;
+      for (let k in e) {
+        const v = e[k];
+        if (empty = !1, assert(k === "p" || k === "r" || k === "d" || k === "i" || k === "e" || k === "es" || k === "ena" || k === "et", "Invalid component item '" + k + "'"), k === "p") checkNonNegInteger(v), assert(!pickedSlots.has(v)), pickedSlots.add(v), assert(e.r === void 0);
+        else if (k === "d") checkNonNegInteger(v), assert(!droppedSlots.has(v)), droppedSlots.add(v), assert(e.i === void 0);
+        else if (k === "e" || k === "es" || k === "ena") {
+          assert(!hasEdit), hasEdit = !0;
+          const t = getEditType(e);
+          assert(t, "Missing type in edit"), t.checkValidOp && t.checkValidOp(getEdit(e));
         }
       }
-      l(!$);
-    }, m = (C, $, T) => {
-      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 j = C[I];
-        if (l(j != null), Array.isArray(j)) {
-          const G = m(j, !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");
+      assert(!empty);
+    }, "checkComponent"), checkDescent = /* @__PURE__ */ __name((descent, isRoot, removed) => {
+      if (!Array.isArray(descent)) throw Error("Op must be null or a list");
+      if (descent.length === 0) throw Error("Empty descent");
+      isRoot || checkScalar(descent[0]);
+      let last = 1, numDescents = 0, lastKey = 0;
+      for (let i = 0; i < descent.length; i++) {
+        const d = descent[i];
+        if (assert(d != null), Array.isArray(d)) {
+          const key = checkDescent(d, !1);
+          if (numDescents) {
+            const t1 = typeof lastKey, t2 = typeof key;
+            t1 === t2 ? assert(lastKey < key, "descent keys are not in order") : assert(t1 === "number" && t2 === "string");
           }
-          b = G, v++, p = 3;
-        } else typeof j == "object" ? (l(p === 1, `Prev not scalar - instead ${p}`), D(j), p = 2) : (l(p !== 3), L(j), l(s.isValidPathItem(j), "Invalid path key"), p = 1);
+          lastKey = key, numDescents++, last = 3;
+        } else typeof d == "object" ? (assert(last === 1, `Prev not scalar - instead ${last}`), checkComponent(d), last = 2) : (assert(last !== 3), checkScalar(d), assert(cursor_js_1.isValidPathItem(d), "Invalid path key"), last = 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);
+      return assert(numDescents !== 1, "Operation makes multiple descents. Remove some []"), assert(last === 2 || last === 3), descent[0];
+    }, "checkDescent");
+    checkDescent(op, !0), assert(pickedSlots.size === droppedSlots.size, "Mismatched picks and drops in op");
+    for (let i = 0; i < pickedSlots.size; i++) assert(pickedSlots.has(i)), assert(droppedSlots.has(i));
+  }
+  __name(checkValidOp, "checkValidOp");
+  function normalize(op) {
+    let nextSlot = 0, slotMap = [];
+    const w = cursor_js_1.writeCursor();
+    return w.mergeTree(op, (c, w2) => {
+      const t = getEditType(c);
+      if (t) {
+        const op2 = getEdit(c);
+        writeEdit(w2, t, t.normalize ? t.normalize(op2) : op2);
       }
-      for (const p of ["r", "p", "i", "d"]) if (m[p] !== void 0) {
-        const v = p === "p" || p === "d" ? (T = m[p], y[T] == null && (y[T] = u++), y[T]) : m[p];
-        C.write(p, v);
+      for (const k of ["r", "p", "i", "d"]) if (c[k] !== void 0) {
+        const r = k === "p" || k === "d" ? (inSlot = c[k], slotMap[inSlot] == null && (slotMap[inSlot] = nextSlot++), slotMap[inSlot]) : c[k];
+        w2.write(k, r);
       }
-      var T;
-    }), D.get();
-  }
-  function De(r, u) {
-    if (z(u), u === null) return r;
-    const y = [];
-    return function D(m, C) {
-      let $ = m, T = 0, p = {
-        root: m
-      }, v = 0, b = p, I = "root";
-      function j() {
-        for (; v < T; v++) {
-          let G = C[v];
-          typeof G != "object" && (l(R(b, I)), b = b[I] = W(b[I]), I = G);
+      var inSlot;
+    }), w.get();
+  }
+  __name(normalize, "normalize");
+  function apply(snapshot, op) {
+    if (checkValidOp(op), op === null) return snapshot;
+    const held = [];
+    return (/* @__PURE__ */ __name(function drop(root, descent) {
+      let subDoc = root, i = 0, rootContainer = {
+        root
+      }, m = 0, container = rootContainer, key = "root";
+      function mut() {
+        for (; m < i; m++) {
+          let d = descent[m];
+          typeof d != "object" && (assert(isValidKey(container, key)), container = container[key] = shallowClone(container[key]), key = d);
         }
       }
-      for (; T < C.length; T++) {
-        const G = C[T];
-        if (Array.isArray(G)) {
-          const g = D($, G);
-          g !== $ && g !== void 0 && (j(), $ = b[I] = g);
-        } else if (typeof G == "object") {
-          G.d != null ? (j(), $ = h(b, I, y[G.d])) : G.i !== void 0 && (j(), $ = h(b, I, G.i));
-          const g = ve(G);
-          if (g) j(), $ = b[I] = g.apply($, f(G));
-          else if (G.e !== void 0) throw Error("Subtype " + G.et + " undefined");
-        } else $ = Z($, G);
+      for (__name(mut, "mut"); i < descent.length; i++) {
+        const d = descent[i];
+        if (Array.isArray(d)) {
+          const child = drop(subDoc, d);
+          child !== subDoc && child !== void 0 && (mut(), subDoc = container[key] = child);
+        } else if (typeof d == "object") {
+          d.d != null ? (mut(), subDoc = insertChildMut(container, key, held[d.d])) : d.i !== void 0 && (mut(), subDoc = insertChildMut(container, key, d.i));
+          const t = getEditType(d);
+          if (t) mut(), subDoc = container[key] = t.apply(subDoc, getEdit(d));
+          else if (d.e !== void 0) throw Error("Subtype " + d.et + " undefined");
+        } else subDoc = maybeGetChild(subDoc, d);
       }
-      return p.root;
-    }(r = function D(m, C) {
-      const $ = [];
-      let T = 0;
-      for (; T < C.length; T++) {
-        const I = C[T];
-        if (Array.isArray(I)) break;
-        typeof I != "object" && ($.push(m), m = Z(m, I));
+      return rootContainer.root;
+    }, "drop"))(snapshot = (/* @__PURE__ */ __name(function pick(subDoc, descent) {
+      const stack = [];
+      let i = 0;
+      for (; i < descent.length; i++) {
+        const d = descent[i];
+        if (Array.isArray(d)) break;
+        typeof d != "object" && (stack.push(subDoc), subDoc = maybeGetChild(subDoc, d));
       }
-      for (let I = C.length - 1; I >= T; I--) m = D(m, C[I]);
-      for (--T; T >= 0; T--) {
-        const I = C[T];
-        if (typeof I != "object") {
-          const j = $.pop();
-          m = m === Z(j, I) ? j : m === void 0 ? c(j, I) : (v = I, b = m, (p = W(p = j))[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);
+      for (let j = descent.length - 1; j >= i; j--) subDoc = pick(subDoc, descent[j]);
+      for (--i; i >= 0; i--) {
+        const d = descent[i];
+        if (typeof d != "object") {
+          const container = stack.pop();
+          subDoc = subDoc === maybeGetChild(container, d) ? container : subDoc === void 0 ? removeChild(container, d) : (k = d, v = subDoc, (obj = shallowClone(obj = container))[k] = v, obj);
+        } else hasPick(d) && (assert(subDoc !== void 0, "Cannot pick up or remove undefined"), d.p != null && (held[d.p] = subDoc), subDoc = 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 j = s.advancer(y, void 0, (g, N) => {
-        O(N) && I++;
+      var obj, k, v;
+      return subDoc;
+    }, "pick"))(snapshot, op), op);
+  }
+  __name(apply, "apply");
+  function transformPosition(path, op) {
+    path = path.slice(), checkValidOp(op);
+    const r = cursor_js_1.readCursor(op);
+    let pickedAtSlot, pickIndex, removed = !1;
+    const advStack = [];
+    for (let i = 0; ; i++) {
+      const k = path[i], c = r.getComponent();
+      if (c && (c.r !== void 0 ? removed = !0 : c.p != null && (removed = !1, pickedAtSlot = c.p, pickIndex = i)), i >= path.length) break;
+      let pickOffset = 0;
+      const pickAdv = cursor_js_1.advancer(r, void 0, (k2, c2) => {
+        hasPick(c2) && pickOffset++;
       });
-      $.unshift(j);
-      const G = j(v);
-      if (typeof v == "number" && (r[p] -= I), !G) break;
+      advStack.unshift(pickAdv);
+      const hasNext = pickAdv(k);
+      if (typeof k == "number" && (path[i] -= pickOffset), !hasNext) break;
     }
-    if ($.forEach((p) => p.end()), C) return null;
-    const T = () => {
-      let p = 0;
-      if (D != null) {
-        const v = y.getPath();
-        p = v.length, r = v.concat(r.slice(m));
+    if (advStack.forEach((pickAdv) => pickAdv.end()), removed) return null;
+    const handleDrop = /* @__PURE__ */ __name(() => {
+      let i = 0;
+      if (pickedAtSlot != null) {
+        const rPath = r.getPath();
+        i = rPath.length, path = rPath.concat(path.slice(pickIndex));
       }
-      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));
+      for (; i < path.length; i++) {
+        const k = path[i], c = getComponent(r), et = getEditType(c);
+        if (et) {
+          const e = getEdit(c);
+          et.transformPosition && (path[i] = et.transformPosition(path[i], e));
           break;
         }
-        let j = 0;
-        const G = s.advancer(y, (g, N) => o(N) ? ~(g - j) : g - j, (g, N) => {
-          o(N) && j++;
-        })(v);
-        if (typeof v == "number" && (r[p] += j), !G) break;
+        let dropOffset = 0;
+        const hasNext = cursor_js_1.advancer(r, (k2, c2) => hasDrop(c2) ? ~(k2 - dropOffset) : k2 - dropOffset, (k2, c2) => {
+          hasDrop(c2) && dropOffset++;
+        })(k);
+        if (typeof k == "number" && (path[i] += dropOffset), !hasNext) break;
       }
-    };
-    return D != null ? y.eachDrop(null, (p) => {
-      p === D && T();
-    }) : T(), 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(), $ = [], T = [], p = [], v = [], b = [], I = [], j = /* @__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());
+    }, "handleDrop");
+    return pickedAtSlot != null ? r.eachDrop(null, (slot) => {
+      slot === pickedAtSlot && handleDrop();
+    }) : handleDrop(), path;
+  }
+  __name(transformPosition, "transformPosition");
+  function compose(op1, op2) {
+    if (checkValidOp(op1), checkValidOp(op2), op1 == null) return op2;
+    if (op2 == null) return op1;
+    let nextSlot = 0;
+    const r1 = cursor_js_1.readCursor(op1), r2 = cursor_js_1.readCursor(op2), w = cursor_js_1.writeCursor(), heldPickWrites = [], heldDropWrites = [], held1Pick = [], held2Drop = [], p1SlotMap = [], p2SlotMap = [], visitedOp2EditCs = /* @__PURE__ */ new Set();
+    r1.traverse(null, (c) => {
+      c.p != null && (held1Pick[c.p] = r1.clone());
+    }), r2.traverse(null, (c) => {
+      c.d != null && (held2Drop[c.d] = r2.clone());
     });
-    const G = s.writeCursor();
-    return function g(N, re, te, K, se, je, me, _e) {
-      l(re || te);
-      const oe = a(re), Pe = a(te), Ue = !!Pe && Pe.r !== void 0, Le = !!oe && oe.i !== void 0, Me = oe ? oe.d : null, Ee = Pe ? Pe.p : null, $e = (je || Ue) && Ee == null;
-      if (Ee != null) K = v[Ee], me = T[Ee] = new s.WriteCursor();
-      else if (Pe && Pe.r !== void 0) K = null;
+    const w2 = cursor_js_1.writeCursor();
+    return (/* @__PURE__ */ __name(function xfBoundary(r1Pick, r1Drop, r2Pick, r2Drop, litIn, rmParent, wd, wp) {
+      assert(r1Drop || r2Pick);
+      const c1d = getComponent(r1Drop), c2p = getComponent(r2Pick), rmHere = !!c2p && c2p.r !== void 0, insHere = !!c1d && c1d.i !== void 0, drop1Slot = c1d ? c1d.d : null, pick2Slot = c2p ? c2p.p : null, rmChildren = (rmParent || rmHere) && pick2Slot == null;
+      if (pick2Slot != null) r2Drop = held2Drop[pick2Slot], wd = heldDropWrites[pick2Slot] = new cursor_js_1.WriteCursor();
+      else if (c2p && c2p.r !== void 0) r2Drop = null;
       else {
-        const P = a(K);
-        P && P.d != null && (K = null);
+        const c2d2 = getComponent(r2Drop);
+        c2d2 && c2d2.d != null && (r2Drop = null);
       }
-      const Q = a(K);
-      if (Me != null) if (N = p[Me], _e = $[Me] = new s.WriteCursor(), $e) je && !Ue && _e.write("r", !0);
+      const c2d = getComponent(r2Drop);
+      if (drop1Slot != null) if (r1Pick = held1Pick[drop1Slot], wp = heldPickWrites[drop1Slot] = new cursor_js_1.WriteCursor(), rmChildren) rmParent && !rmHere && wp.write("r", !0);
       else {
-        const P = b[Me] = y++;
-        me.write("d", P);
+        const slot = p1SlotMap[drop1Slot] = nextSlot++;
+        wd.write("d", slot);
       }
-      else if (oe && oe.i !== void 0) N = null;
+      else if (c1d && c1d.i !== void 0) r1Pick = null;
       else {
-        const P = a(N);
-        P && P.p != null && (N = null);
+        const c1p = getComponent(r1Pick);
+        c1p && c1p.p != null && (r1Pick = null);
       }
-      let M;
-      Le ? (l(se === void 0), M = oe.i) : M = se;
-      const B = (Ee == null ? !Le || je || Ue : M === void 0) ? null : me.getComponent();
-      if (Ee != null) {
-        if (!(se !== void 0 || Le)) {
-          const P = Me != null ? b[Me] : y++;
-          I[Ee] = P, _e.write("p", P);
+      let litOut;
+      insHere ? (assert(litIn === void 0), litOut = c1d.i) : litOut = litIn;
+      const insComponent = (pick2Slot == null ? !insHere || rmParent || rmHere : litOut === void 0) ? null : wd.getComponent();
+      if (pick2Slot != null) {
+        if (!(litIn !== void 0 || insHere)) {
+          const slot = drop1Slot != null ? p1SlotMap[drop1Slot] : nextSlot++;
+          p2SlotMap[pick2Slot] = slot, wp.write("p", slot);
         }
-      } else Ue && (Le || se !== void 0 || (Pe.r, _e.write("r", Pe.r)));
-      const U = $e ? null : ve(oe), A = ve(Q);
-      if ((U || A) && (U && U.name, A && A.name), U && A) {
-        l(U === A);
-        const P = f(oe), x = f(Q), he = U.compose(P, x);
-        _(me, U, he), j.add(Q);
-      } else U ? _(me, U, f(oe)) : A && (_(me, A, f(Q)), j.add(Q));
-      const k = typeof M == "object" && M != 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++;
+      } else rmHere && (insHere || litIn !== void 0 || (c2p.r, wp.write("r", c2p.r)));
+      const type1 = rmChildren ? null : getEditType(c1d), type2 = getEditType(c2d);
+      if ((type1 || type2) && (type1 && type1.name, type2 && type2.name), type1 && type2) {
+        assert(type1 === type2);
+        const e1 = getEdit(c1d), e2 = getEdit(c2d), r = type1.compose(e1, e2);
+        writeEdit(wd, type1, r), visitedOp2EditCs.add(c2d);
+      } else type1 ? writeEdit(wd, type1, getEdit(c1d)) : type2 && (writeEdit(wd, type2, getEdit(c2d)), visitedOp2EditCs.add(c2d));
+      const hasContainerLiteral = typeof litOut == "object" && litOut != null;
+      let isCloned = !1, p1PickOff = 0, p1DropOff = 0, p2PickOff = 0, p2DropOff = 0, litOff = 0;
+      const p2DropAdv = cursor_js_1.advancer(r2Drop, (k, c) => hasDrop(c) ? p2DropOff - k - 1 : k - p2DropOff, (k, c) => {
+        hasDrop(c) && p2DropOff++;
+      }), p1PickAdv = cursor_js_1.advancer(r1Pick, (k, c) => hasPick(c) ? p1PickOff - k - 1 : k - p1PickOff, (k, c) => {
+        hasPick(c) && p1PickOff++;
       });
-      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 ke = o(a(x)), Ge = O(a(he));
-          (ke || Ge && !$e) && le--, ke && ee--, Ge && fe--;
-        } else be = q(P), We = ye(P);
-        _e.descend(He), me.descend(Ne);
-        const ze = k && !o(a(x)) ? M[Ye] : void 0, Se = g(be, x, he, We, ze, $e, me, _e);
-        var Te, S, ie;
-        k && !$e ? ze !== Se && (X || (M = Array.isArray(M) ? M.slice() : Object.assign({}, M), X = !0), Te = M, ie = Se, typeof (S = Ye) == "number" ? (l(Array.isArray(Te)), l(S < Te.length)) : (l(!Array.isArray(Te)), l(Te[S] !== void 0)), ie === void 0 ? typeof S == "number" ? Te.splice(S, 1) : delete Te[S] : Te[S] = ie) : l(Se === void 0), me.ascend(), _e.ascend();
-      }), q.end(), ye.end(), B != null) B.i = M;
-      else if (!je && !Ue && Ee == null) return M;
-    }(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()), T.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 = T[re];
-        se && N.mergeTree(se.get());
-      } else g.i !== void 0 && N.write("i", g.i);
-      const te = ve(g);
-      te && !j.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 $(T, p, v) {
-      const b = T.getComponent();
-      let I, j = !1;
-      if (b) {
-        b.p != null && (p.write("d", b.p), m[b.p] = T.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)), j = !0));
+      if (cursor_js_1.eachChildOf(r1Drop, r2Pick, (inKey, _p1Drop, _p2Pick) => {
+        let _p1Pick, _p2Drop, p1PickKey = inKey, p2DropKey = inKey, litKey = inKey;
+        if (typeof inKey == "number") {
+          let p2Mid = inKey + p2PickOff;
+          _p2Drop = p2DropAdv(p2Mid), p2DropKey = p2Mid + p2DropOff;
+          let p1Mid = inKey + p1DropOff;
+          _p1Pick = p1PickAdv(p1Mid), hasDrop(getComponent(_p2Drop)) && (_p1Pick = null), p1PickKey = p1Mid + p1PickOff, litKey = inKey + litOff, assert(p1PickKey >= 0, "p1PickKey is negative"), assert(p2DropKey >= 0, "p2DropKey is negative");
+          const hd1 = hasDrop(getComponent(_p1Drop)), hp2 = hasPick(getComponent(_p2Pick));
+          (hd1 || hp2 && !rmChildren) && litOff--, hd1 && p1DropOff--, hp2 && p2PickOff--;
+        } else _p1Pick = p1PickAdv(inKey), _p2Drop = p2DropAdv(inKey);
+        wp.descend(p1PickKey), wd.descend(p2DropKey);
+        const _lit = hasContainerLiteral && !hasDrop(getComponent(_p1Drop)) ? litOut[litKey] : void 0, _litResult = xfBoundary(_p1Pick, _p1Drop, _p2Pick, _p2Drop, _lit, rmChildren, wd, wp);
+        var container, key, child;
+        hasContainerLiteral && !rmChildren ? _lit !== _litResult && (isCloned || (litOut = Array.isArray(litOut) ? litOut.slice() : Object.assign({}, litOut), isCloned = !0), container = litOut, child = _litResult, typeof (key = litKey) == "number" ? (assert(Array.isArray(container)), assert(key < container.length)) : (assert(!Array.isArray(container)), assert(container[key] !== void 0)), child === void 0 ? typeof key == "number" ? container.splice(key, 1) : delete container[key] : container[key] = child) : assert(_litResult === void 0), wd.ascend(), wp.ascend();
+      }), p1PickAdv.end(), p2DropAdv.end(), insComponent != null) insComponent.i = litOut;
+      else if (!rmParent && !rmHere && pick2Slot == null) return litOut;
+    }, "xfBoundary"))(r1, r1.clone(), r2, r2.clone(), void 0, !1, w, w2), w.reset(), w.mergeTree(w2.get()), w.reset(), w.get(), heldPickWrites.map((w3) => w3.get()), heldDropWrites.map((w3) => w3.get()), r1.traverse(w, (c, w3) => {
+      const slot1 = c.p;
+      if (slot1 != null) {
+        const slot = p1SlotMap[slot1];
+        slot != null && w3.write("p", slot);
+        const _w = heldPickWrites[slot1];
+        _w && _w.get(), _w && w3.mergeTree(_w.get());
+      } else c.r !== void 0 && w3.write("r", c.r);
+    }), w.reset(), w.get(), r2.traverse(w, (c, w3) => {
+      const slot2 = c.d;
+      if (slot2 != null) {
+        const slot = p2SlotMap[slot2];
+        slot != null && w3.write("d", slot);
+        const _w = heldDropWrites[slot2];
+        _w && w3.mergeTree(_w.get());
+      } else c.i !== void 0 && w3.write("i", c.i);
+      const t = getEditType(c);
+      t && !visitedOp2EditCs.has(c) && writeEdit(w3, t, getEdit(c));
+    }), w.get();
+  }
+  __name(compose, "compose");
+  function invert(op) {
+    if (op == null) return null;
+    const r = new cursor_js_1.ReadCursor(op), w = new cursor_js_1.WriteCursor();
+    let editsToTransform;
+    const heldPick = [], heldWrites = [];
+    return (/* @__PURE__ */ __name(function invertSimple(r2, w2, subDoc) {
+      const c = r2.getComponent();
+      let insertHere, subdocModified = !1;
+      if (c) {
+        c.p != null && (w2.write("d", c.p), heldPick[c.p] = r2.clone()), c.r !== void 0 && w2.write("i", c.r), c.d != null && (w2.write("p", c.d), subDoc = void 0), c.i !== void 0 && (subDoc = insertHere = c.i);
+        const t = getEditType(c);
+        t && (subDoc === void 0 ? (editsToTransform || (editsToTransform = /* @__PURE__ */ new Set()), editsToTransform.add(c)) : (getEdit(c), subDoc = t.apply(subDoc, getEdit(c)), subdocModified = !0));
       }
-      let G = 0;
-      for (const g of T) {
-        p.descend(g);
-        const N = typeof g == "number" ? g - G : g, re = Z(v, N);
-        o(T.getComponent()) && G++;
-        const te = $(T, p, re);
-        if (v !== void 0 && te !== void 0) {
-          if (j || (j = !0, v = W(v)), !R(v, N)) throw Error("Cannot modify child - invalid operation");
-          v[N] = te;
+      let dropOff = 0;
+      for (const key of r2) {
+        w2.descend(key);
+        const raw = typeof key == "number" ? key - dropOff : key, childIn = maybeGetChild(subDoc, raw);
+        hasDrop(r2.getComponent()) && dropOff++;
+        const childOut = invertSimple(r2, w2, childIn);
+        if (subDoc !== void 0 && childOut !== void 0) {
+          if (subdocModified || (subdocModified = !0, subDoc = shallowClone(subDoc)), !isValidKey(subDoc, raw)) throw Error("Cannot modify child - invalid operation");
+          subDoc[raw] = childOut;
         }
-        p.ascend();
+        w2.ascend();
       }
-      if (I === void 0) return j ? v : void 0;
-      p.write("r", v);
-    }(u, y, void 0), D && (y.reset(), function $(T, p, v) {
-      const b = p.getComponent();
-      if (b) {
-        const g = b.d;
-        if (g != null && (T = 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)));
+      if (insertHere === void 0) return subdocModified ? subDoc : void 0;
+      w2.write("r", subDoc);
+    }, "invertSimple"))(r, w, void 0), editsToTransform && (w.reset(), (/* @__PURE__ */ __name(function transformEdits(rPick, rDrop, w2) {
+      const cd = rDrop.getComponent();
+      if (cd) {
+        const dropSlot = cd.d;
+        if (dropSlot != null && (rPick = heldPick[dropSlot], w2 = heldWrites[dropSlot] = cursor_js_1.writeCursor()), editsToTransform.has(cd)) {
+          const t = getEditType(cd);
+          if (!t.invert) throw Error(`Cannot invert subtype ${t.name}`);
+          writeEdit(w2, t, t.invert(getEdit(cd)));
         }
       }
-      let I = 0, j = 0;
-      const G = s.advancer(T, (g, N) => O(N) ? I - g - 1 : g - I, (g, N) => {
-        O(N) && I++;
+      let pickOff = 0, dropOff = 0;
+      const ap = cursor_js_1.advancer(rPick, (k, c) => hasPick(c) ? pickOff - k - 1 : k - pickOff, (k, c) => {
+        hasPick(c) && pickOff++;
       });
-      for (const g of p) if (typeof g == "number") {
-        const N = g - j, re = G(N), te = N + I;
-        v.descend(te), $(re, p, v), o(p.getComponent()) && j++, 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, ($, T) => {
-      const p = $.p;
-      if (p != null) {
-        const v = C[p];
-        v && v.get(), v && T.mergeTree(v.get());
+      for (const key of rDrop) if (typeof key == "number") {
+        const mid = key - dropOff, _rPick = ap(mid), raw = mid + pickOff;
+        w2.descend(raw), transformEdits(_rPick, rDrop, w2), hasDrop(rDrop.getComponent()) && dropOff++, w2.ascend();
+      } else w2.descend(key), transformEdits(ap(key), rDrop, w2), w2.ascend();
+      ap.end();
+    }, "transformEdits"))(r.clone(), r, w), heldWrites.length && (w.reset(), r.traverse(w, (c, w2) => {
+      const slot = c.p;
+      if (slot != null) {
+        const _w = heldWrites[slot];
+        _w && _w.get(), _w && w2.mergeTree(_w.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 = [], $ = [], T = (p, v, b) => {
-      const I = p.getComponent();
-      let j = !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));
+    }))), w.get();
+  }
+  __name(invert, "invert");
+  const anyComponent = /* @__PURE__ */ __name((op, fn) => op.some((c) => typeof c == "object" && (Array.isArray(c) ? anyComponent(c, fn) : fn(c))), "anyComponent");
+  function makeInvertible(op, doc) {
+    if (op == null || !anyComponent(op, (c) => {
+      var _a2;
+      return c.r !== void 0 || ((_a2 = getEditType(c)) === null || _a2 === void 0 ? void 0 : _a2.makeInvertible) != null;
+    })) return op;
+    const r = new cursor_js_1.ReadCursor(op), w = new cursor_js_1.WriteCursor();
+    let hasEdits = !1;
+    const heldPick = [], heldDoc = [], traversePick = /* @__PURE__ */ __name((r2, w2, subDoc) => {
+      const c = r2.getComponent();
+      let modified = !1;
+      if (c) {
+        c.d != null && w2.write("d", c.d), c.i !== void 0 && w2.write("i", c.i);
+        const pickSlot = c.p;
+        if (pickSlot != null && (heldPick[pickSlot] = r2.clone(), assert(subDoc !== void 0, "Operation picks up at an invalid key"), heldDoc[pickSlot] = subDoc, w2.write("p", c.p)), c.r !== void 0 && subDoc === void 0) throw Error("Invalid doc / op in makeInvertible: removed item missing from doc");
+        const t = getEditType(c);
+        t && (t.makeInvertible ? hasEdits = !0 : writeEdit(w2, t, getEdit(c), !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 = T(p, v, re);
-        re !== te && (j || (j = !0, b = W(b)), te === void 0 ? (b = c(b, N), typeof g == "number" && G++) : b[N] = te), v.ascend();
+      let listOff = 0;
+      for (const key of r2) {
+        w2.descend(key);
+        const keyRaw = typeof key == "number" ? key - listOff : key, childIn = maybeGetChild(subDoc, keyRaw), childOut = traversePick(r2, w2, childIn);
+        childIn !== childOut && (modified || (modified = !0, subDoc = shallowClone(subDoc)), childOut === void 0 ? (subDoc = removeChild(subDoc, keyRaw), typeof key == "number" && listOff++) : subDoc[keyRaw] = childOut), w2.ascend();
       }
-      return I && (I.r !== void 0 ? (v.write("r", i.default(b)), b = void 0) : I.p != null && (b = void 0)), b;
-    };
-    return T(y, D, u), D.get(), m && (D.reset(), function p(v, b, I, j, G) {
-      const g = b.getComponent();
-      if (g) {
-        g.i !== void 0 ? (j = g.i, G = !0) : g.d != null && (j = $[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, j), !0);
+      return c && (c.r !== void 0 ? (w2.write("r", deepClone_js_1.default(subDoc)), subDoc = void 0) : c.p != null && (subDoc = void 0)), subDoc;
+    }, "traversePick");
+    return traversePick(r, w, doc), w.get(), hasEdits && (w.reset(), (/* @__PURE__ */ __name(function traverseDrop(rPick, rDrop, w2, subDoc, isLiteral) {
+      const c = rDrop.getComponent();
+      if (c) {
+        c.i !== void 0 ? (subDoc = c.i, isLiteral = !0) : c.d != null && (subDoc = heldDoc[c.d], rPick = heldPick[c.d], isLiteral = !1, c.d);
+        let t = getEditType(c);
+        if (t && t.makeInvertible) {
+          const edit = getEdit(c);
+          writeEdit(w2, t, t.makeInvertible(edit, subDoc), !0);
         }
       }
-      let N = 0, re = 0;
-      const te = s.advancer(v, (K, se) => O(se) ? N - K - 1 : K - N, (K, se) => {
-        O(se) && N++;
+      let pickOff = 0, dropOff = 0;
+      const ap = cursor_js_1.advancer(rPick, (k, c2) => hasPick(c2) ? pickOff - k - 1 : k - pickOff, (k, c2) => {
+        hasPick(c2) && pickOff++;
       });
-      for (const K of b) if (typeof K == "number") {
-        const se = K - re, je = te(se), me = se + N, _e = Z(j, G ? se : me);
-        I.descend(K), p(je, b, I, _e, G), o(b.getComponent()) && re++, I.ascend();
+      for (const key of rDrop) if (typeof key == "number") {
+        const mid = key - dropOff, _rPick = ap(mid), raw = mid + pickOff, child = maybeGetChild(subDoc, isLiteral ? mid : raw);
+        w2.descend(key), traverseDrop(_rPick, rDrop, w2, child, isLiteral), hasDrop(rDrop.getComponent()) && dropOff++, w2.ascend();
       } else {
-        const se = Z(j, K);
-        I.descend(K), p(te(K), b, I, se, G), I.ascend();
+        const child = maybeGetChild(subDoc, key);
+        w2.descend(key), traverseDrop(ap(key), rDrop, w2, child, isLiteral), w2.ascend();
       }
-      te.end();
-    }(y.clone(), y, D, u, !1)), D.get();
-  }
-  function Et(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));
+      ap.end();
+    }, "traverseDrop"))(r.clone(), r, w, doc, !1)), w.get();
+  }
+  __name(makeInvertible, "makeInvertible");
+  function invertWithDoc(op, doc) {
+    return invert(makeInvertible(op, doc));
+  }
+  __name(invertWithDoc, "invertWithDoc");
+  const shallowCloneOp = /* @__PURE__ */ __name((op) => {
+    if (op == null) return null;
+    const result = op.slice();
+    for (let i = 0; i < op.length; i++) {
+      const c = result[i];
+      Array.isArray(c) && (result[i] = shallowCloneOp(c));
     }
-    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 {
+    return result;
+  }, "shallowCloneOp");
+  function tryTransform(op1, op2, direction) {
+    assert(direction === "left" || direction === "right", "Direction must be left or right");
+    const side = direction === "left" ? 0 : 1;
+    if (op2 == null) return {
       ok: !0,
-      result: r
+      result: op1
     };
-    z(r), z(u);
-    let m = null;
-    const C = [], $ = [], T = [], p = [], v = [], b = [], I = [], j = [], G = [], g = [], N = [], re = [], te = [], K = [], se = [];
-    let je = 0;
-    const me = s.readCursor(r), _e = s.readCursor(u), oe = s.writeCursor();
-    if (function Q(M, B = null, U) {
-      const A = a(B);
-      A && (A.r !== void 0 ? U = B.clone() : A.p != null && (U = null, b[A.p] = M.clone()));
-      const k = M.getComponent();
-      let X;
-      k && (X = k.p) != null && (v[X] = B ? B.clone() : null, T[X] = M.clone(), U && (g[X] = !0, G[X] = U), A && A.p != null && (K[X] = A.p));
-      const Y = s.advancer(B);
-      for (const ee of M) Q(M, Y(ee), U);
-      Y.end();
-    }(_e, me, null), function Q(M, B, U, A, k) {
-      const X = U.getComponent();
-      let Y, ee = !1;
-      X && ((Y = X.d) != null ? (p[Y] = U.clone(), A != null && (se[A] == null && (se[A] = []), se[A].push(Y)), M = v[Y] || null, B = T[Y] || null, g[Y] ? (k && (N[Y] = !0), k = G[Y] || null) : !k || D !== 1 && K[Y] != null || m == null && (m = {
-        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-        op1: n.removeOp(k.getPath()),
-        op2: n.moveOp(B.getPath(), U.getPath())
-      }), ee = !0) : X.i !== void 0 && (M = B = null, ee = !0, k && m == null && (m = {
-        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-        op1: n.removeOp(k.getPath()),
-        op2: n.insertOp(U.getPath(), X.i)
+    checkValidOp(op1), checkValidOp(op2);
+    let conflict = null;
+    const heldOp1PickByOp1 = [], heldOp1DropByOp1 = [], heldOp2PickByOp2 = [], heldOp2DropByOp2 = [], heldOp1PickByOp2 = [], heldOp2PickByOp1 = [], heldOp2DropByOp1 = [], heldOp2RmForOp1 = [], heldOp1RmForOp2 = [], cancelledOp2 = [], discardedOp2Drop = [], heldPickWrites = [], heldDropWrites = [], op1PickAtOp2Pick = [], op1PicksOp2DropSlots = [];
+    let nextSlot = 0;
+    const r1 = cursor_js_1.readCursor(op1), r2 = cursor_js_1.readCursor(op2), w = cursor_js_1.writeCursor();
+    if ((/* @__PURE__ */ __name(function scanOp2Pick(r2Pick, r1Pick = null, removed1) {
+      const c1 = getComponent(r1Pick);
+      c1 && (c1.r !== void 0 ? removed1 = r1Pick.clone() : c1.p != null && (removed1 = null, heldOp2PickByOp1[c1.p] = r2Pick.clone()));
+      const c2 = r2Pick.getComponent();
+      let slot2;
+      c2 && (slot2 = c2.p) != null && (heldOp1PickByOp2[slot2] = r1Pick ? r1Pick.clone() : null, heldOp2PickByOp2[slot2] = r2Pick.clone(), removed1 && (cancelledOp2[slot2] = !0, heldOp1RmForOp2[slot2] = removed1), c1 && c1.p != null && (op1PickAtOp2Pick[slot2] = c1.p));
+      const ap1 = cursor_js_1.advancer(r1Pick);
+      for (const key of r2Pick) scanOp2Pick(r2Pick, ap1(key), removed1);
+      ap1.end();
+    }, "scanOp2Pick"))(r2, r1, null), (/* @__PURE__ */ __name(function scanOp2Drop(r1Pick, r2Pick, r2Drop, pickSlot1, removed1) {
+      const c2d = r2Drop.getComponent();
+      let slot2, droppedHere = !1;
+      c2d && ((slot2 = c2d.d) != null ? (heldOp2DropByOp2[slot2] = r2Drop.clone(), pickSlot1 != null && (op1PicksOp2DropSlots[pickSlot1] == null && (op1PicksOp2DropSlots[pickSlot1] = []), op1PicksOp2DropSlots[pickSlot1].push(slot2)), r1Pick = heldOp1PickByOp2[slot2] || null, r2Pick = heldOp2PickByOp2[slot2] || null, cancelledOp2[slot2] ? (removed1 && (discardedOp2Drop[slot2] = !0), removed1 = heldOp1RmForOp2[slot2] || null) : !removed1 || side !== 1 && op1PickAtOp2Pick[slot2] != null || conflict == null && (conflict = {
+        type: types_js_1.ConflictType.RM_UNEXPECTED_CONTENT,
+        op1: exports.removeOp(removed1.getPath()),
+        op2: exports.moveOp(r2Pick.getPath(), r2Drop.getPath())
+      }), droppedHere = !0) : c2d.i !== void 0 && (r1Pick = r2Pick = null, droppedHere = !0, removed1 && conflict == null && (conflict = {
+        type: types_js_1.ConflictType.RM_UNEXPECTED_CONTENT,
+        op1: exports.removeOp(removed1.getPath()),
+        op2: exports.insertOp(r2Drop.getPath(), c2d.i)
       })));
-      const fe = a(M);
-      fe && (fe.r !== void 0 ? k = M.clone() : fe.p != null && (fe.p, A = fe.p, k = null));
-      const de = ve(X);
-      de && k && m == null && (m = {
-        type: d.ConflictType.RM_UNEXPECTED_CONTENT,
-        op1: n.removeOp(k.getPath()),
-        op2: n.editOp(U.getPath(), de, f(X), !0)
+      const c1p = getComponent(r1Pick);
+      c1p && (c1p.r !== void 0 ? removed1 = r1Pick.clone() : c1p.p != null && (c1p.p, pickSlot1 = c1p.p, removed1 = null));
+      const t2 = getEditType(c2d);
+      t2 && removed1 && conflict == null && (conflict = {
+        type: types_js_1.ConflictType.RM_UNEXPECTED_CONTENT,
+        op1: exports.removeOp(removed1.getPath()),
+        op2: exports.editOp(r2Drop.getPath(), t2, getEdit(c2d), !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(M);
-      for (const x of U) if (typeof x == "number") {
-        const he = x - ye, be = q(he);
-        ye += +Q(P(he + le), be, U, A, k);
+      let p2PickOff = 0, p2DropOff = 0;
+      const ap2 = cursor_js_1.advancer(r2Pick, (k, c) => hasPick(c) ? p2PickOff - k - 1 : k - p2PickOff, (k, c) => {
+        hasPick(c) && p2PickOff++;
+      }), ap1 = cursor_js_1.advancer(r1Pick);
+      for (const key of r2Drop) if (typeof key == "number") {
+        const p2Mid = key - p2DropOff, _p2Pick = ap2(p2Mid);
+        p2DropOff += +scanOp2Drop(ap1(p2Mid + p2PickOff), _p2Pick, r2Drop, pickSlot1, removed1);
       } else {
-        const he = q(x);
-        Q(P(x), he, U, A, k);
+        const _p2Pick = ap2(key);
+        scanOp2Drop(ap1(key), _p2Pick, r2Drop, pickSlot1, removed1);
       }
-      return q.end(), P.end(), ee;
-    }(me, _e, _e.clone(), null, null), p.map((Q) => Q && Q.get()), m) return {
+      return ap2.end(), ap1.end(), droppedHere;
+    }, "scanOp2Drop"))(r1, r2, r2.clone(), null, null), heldOp2DropByOp2.map((x) => x && x.get()), conflict) return {
       ok: !1,
-      conflict: m
+      conflict
     };
-    N.map((Q) => !!Q);
-    const Pe = [];
-    let Ue = null;
-    (function Q(M, B, U, A, k) {
-      let X = !1;
-      const Y = a(B);
-      if (O(Y)) {
-        const q = Y.p;
-        q != null ? (U = p[q], A = re[q] = s.writeCursor(), X = !0, k = null) : (U = null, k = B.clone());
-      } else o(a(U)) && (U = null);
-      const ee = M.getComponent();
-      if (ee) {
-        const q = ee.p;
-        q != null ? (k && (j[q] = k), Pe[q] = k || D === 1 && X ? null : A.getComponent(), C[q] = M.clone(), U && (I[q] = U.clone())) : ee.r !== void 0 && (k || A.write("r", !0), (k || X) && (Ue == null && (Ue = /* @__PURE__ */ new Set()), Ue.add(ee)));
+    discardedOp2Drop.map((x) => !!x);
+    const pickComponents = [];
+    let cancelledRemoves = null;
+    (/* @__PURE__ */ __name(function writeOp1Pick(r1Pick, r2Pick, r2Drop, w2, removed2) {
+      let iAmMoved = !1;
+      const c2p = getComponent(r2Pick);
+      if (hasPick(c2p)) {
+        const slot2 = c2p.p;
+        slot2 != null ? (r2Drop = heldOp2DropByOp2[slot2], w2 = heldPickWrites[slot2] = cursor_js_1.writeCursor(), iAmMoved = !0, removed2 = null) : (r2Drop = null, removed2 = r2Pick.clone());
+      } else hasDrop(getComponent(r2Drop)) && (r2Drop = null);
+      const c1 = r1Pick.getComponent();
+      if (c1) {
+        const slot1 = c1.p;
+        slot1 != null ? (removed2 && (heldOp2RmForOp1[slot1] = removed2), pickComponents[slot1] = removed2 || side === 1 && iAmMoved ? null : w2.getComponent(), heldOp1PickByOp1[slot1] = r1Pick.clone(), r2Drop && (heldOp2DropByOp1[slot1] = r2Drop.clone())) : c1.r !== void 0 && (removed2 || w2.write("r", !0), (removed2 || iAmMoved) && (cancelledRemoves == null && (cancelledRemoves = /* @__PURE__ */ new Set()), cancelledRemoves.add(c1)));
       }
-      let fe = 0, de = 0;
-      const le = s.advancer(B, void 0, (q, P) => {
-        O(P) && fe++;
-      }), ye = s.advancer(U, (q, P) => o(P) ? ~(q - de) : q - de, (q, P) => {
-        o(P) && de++;
+      let p2PickOff = 0, p2DropOff = 0;
+      const ap2Pick = cursor_js_1.advancer(r2Pick, void 0, (k, c) => {
+        hasPick(c) && p2PickOff++;
+      }), ap2Drop = cursor_js_1.advancer(r2Drop, (k, c) => hasDrop(c) ? ~(k - p2DropOff) : k - p2DropOff, (k, c) => {
+        hasDrop(c) && p2DropOff++;
       });
-      if (M) for (const q of M) if (typeof q == "string") {
-        const P = le(q), x = ye(q);
-        A.descend(q), Q(M, P, x, A, k), A.ascend();
+      if (r1Pick) for (const key of r1Pick) if (typeof key == "string") {
+        const p2Pick_ = ap2Pick(key), p2Drop_ = ap2Drop(key);
+        w2.descend(key), writeOp1Pick(r1Pick, p2Pick_, p2Drop_, w2, removed2), w2.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(M, P, he, A, k), A.ascend();
+        const p2Pick_ = ap2Pick(key), p2Mid = key - p2PickOff, p2Drop_ = hasPick(getComponent(p2Pick_)) ? null : ap2Drop(p2Mid), finalKey = p2Mid + p2DropOff;
+        assert(finalKey >= 0), w2.descend(finalKey), writeOp1Pick(r1Pick, p2Pick_, p2Drop_, w2, removed2), w2.ascend();
       }
-      le.end(), ye.end();
-    })(me, _e, _e.clone(), oe, null), oe.reset();
-    let Le = [];
-    if (function Q(M, B, U, A, k, 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 ? T[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[je] = S, k.write("d", ie.p = je++)) : k.write("i", i.default(Y.i)), fe = !0));
-        } else if (S != null && !ie) {
-          const ce = j[S];
-          ce && (X = ce.clone());
+      ap2Pick.end(), ap2Drop.end();
+    }, "writeOp1Pick"))(r1, r2, r2.clone(), w, null), w.reset();
+    let outputSlotMap = [];
+    if ((/* @__PURE__ */ __name(function writeOp1Drop(p1Pick, p1Drop, p2Pick, p2Drop, w2, removed2) {
+      assert(p1Drop);
+      const c1d = p1Drop.getComponent();
+      let c2d = getComponent(p2Drop), droppedHere = !1;
+      const insOrMv = /* @__PURE__ */ __name((r12, r22, c) => r12 ? exports.moveOp(r12.getPath(), r22.getPath()) : exports.insertOp(r22.getPath(), c.i), "insOrMv");
+      if (hasDrop(c1d)) {
+        const slot1 = c1d.d;
+        slot1 != null && (heldOp1DropByOp1[slot1] = p1Drop.clone());
+        const pc = slot1 != null ? pickComponents[slot1] : null;
+        let identical = !1;
+        if (c1d.i !== void 0 || slot1 != null && pc) {
+          let slot2;
+          c2d && (c2d.i !== void 0 || (slot2 = c2d.d) != null && !cancelledOp2[slot2]) && (identical = slot2 != null ? slot1 != null && slot1 === op1PickAtOp2Pick[slot2] : deepEqual_js_1.default(c2d.i, c1d.i), identical || slot2 != null && side !== 1 && op1PickAtOp2Pick[slot2] != null || conflict == null && (conflict = {
+            type: types_js_1.ConflictType.DROP_COLLISION,
+            op1: insOrMv(slot1 != null ? heldOp1PickByOp1[slot1] : null, p1Drop, c1d),
+            op2: insOrMv(slot2 != null ? heldOp2PickByOp2[slot2] : null, p2Drop, c2d)
+          })), identical || (removed2 ? conflict == null && (conflict = {
+            type: types_js_1.ConflictType.RM_UNEXPECTED_CONTENT,
+            op1: insOrMv(slot1 != null ? heldOp1PickByOp1[slot1] : null, p1Drop, c1d),
+            op2: exports.removeOp(removed2.getPath())
+          }) : (slot1 != null ? (outputSlotMap[nextSlot] = slot1, w2.write("d", pc.p = nextSlot++)) : w2.write("i", deepClone_js_1.default(c1d.i)), droppedHere = !0));
+        } else if (slot1 != null && !pc) {
+          const h = heldOp2RmForOp1[slot1];
+          h && (removed2 = h.clone());
         }
-        S != null ? (M = C[S], U = b[S], A = I[S]) : Y.i !== void 0 && (M = U = null, Oe || (A = null));
-      } else O(a(M)) && (M = U = A = null);
-      const le = a(M), ye = a(U);
-      if (O(ye)) {
-        const S = ye.p;
-        ye.r !== void 0 && (!le || le.r === void 0) || g[S] ? (A = null, X = U.clone()) : S != null && (A = p[S], D !== 1 && K[S] != null || ((k = te[S]) || (k = te[S] = s.writeCursor()), k.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())
+        slot1 != null ? (p1Pick = heldOp1PickByOp1[slot1], p2Pick = heldOp2PickByOp1[slot1], p2Drop = heldOp2DropByOp1[slot1]) : c1d.i !== void 0 && (p1Pick = p2Pick = null, identical || (p2Drop = null));
+      } else hasPick(getComponent(p1Pick)) && (p1Pick = p2Pick = p2Drop = null);
+      const c1p = getComponent(p1Pick), c2p = getComponent(p2Pick);
+      if (hasPick(c2p)) {
+        const slot2 = c2p.p;
+        c2p.r !== void 0 && (!c1p || c1p.r === void 0) || cancelledOp2[slot2] ? (p2Drop = null, removed2 = p2Pick.clone()) : slot2 != null && (p2Drop = heldOp2DropByOp2[slot2], side !== 1 && op1PickAtOp2Pick[slot2] != null || ((w2 = heldDropWrites[slot2]) || (w2 = heldDropWrites[slot2] = cursor_js_1.writeCursor()), w2.reset(), removed2 = null));
+      } else !hasDrop(c1d) && hasDrop(c2d) && (p2Drop = null);
+      c2d = p2Drop != null ? p2Drop.getComponent() : null;
+      const t1 = getEditType(c1d);
+      if (t1) {
+        const e1 = getEdit(c1d);
+        if (removed2) conflict == null && (conflict = {
+          type: types_js_1.ConflictType.RM_UNEXPECTED_CONTENT,
+          op1: exports.editOp(p1Drop.getPath(), t1, e1, !0),
+          op2: exports.removeOp(removed2.getPath())
         });
         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);
-          _(k, q, Oe);
+          const t2 = getEditType(c2d);
+          let e;
+          if (t2) {
+            if (t1 !== t2) throw Error("Transforming incompatible types");
+            const e2 = getEdit(c2d);
+            e = t1.transform(e1, e2, direction);
+          } else e = deepClone_js_1.default(e1);
+          writeEdit(w2, t1, e);
         }
       }
-      let P = 0, x = 0, he = 0, be = 0, We = 0, He = 0, Ne = M != null && M.descendFirst(), Ye = Ne;
-      const ze = s.advancer(U, void 0, (S, ie) => {
-        O(ie) && he++;
+      let p1PickOff = 0, p1DropOff = 0, p2PickOff = 0, p2DropOff = 0, outPickOff = 0, outDropOff = 0, p1pValid = p1Pick != null && p1Pick.descendFirst(), p1pDidDescend = p1pValid;
+      const ap2p = cursor_js_1.advancer(p2Pick, void 0, (k, c) => {
+        hasPick(c) && p2PickOff++;
       });
-      let Se = A != null && A.descendFirst(), Te = Se;
-      for (const S of B) if (typeof S == "number") {
-        let ie;
-        const Oe = o(B.getComponent()), ce = S - x;
+      let p2dValid = p2Drop != null && p2Drop.descendFirst(), p2dDidDescend = p2dValid;
+      for (const key of p1Drop) if (typeof key == "number") {
+        let _p1Pick;
+        const hd1 = hasDrop(p1Drop.getComponent()), k1Mid = key - p1DropOff;
         {
-          let Be;
-          for (; Ne && typeof (Be = M.getKey()) == "number"; ) {
-            Be += P;
-            const Re = M.getComponent(), Xe = O(Re);
-            if (Be > ce || Be === ce && (!Xe || D === 0 && Oe)) break;
-            if (Xe) {
-              P--;
-              const Ke = Re.p;
-              K.includes(Ke), Re.d, a(te[Re.d]), O(a(te[Re.d])), (Re.r === void 0 || Ue && Ue.has(Re)) && (Ke == null || !Pe[Ke] || D !== 1 && K.includes(Ke)) || We--;
+          let p1k;
+          for (; p1pValid && typeof (p1k = p1Pick.getKey()) == "number"; ) {
+            p1k += p1PickOff;
+            const c = p1Pick.getComponent(), hp = hasPick(c);
+            if (p1k > k1Mid || p1k === k1Mid && (!hp || side === 0 && hd1)) break;
+            if (hp) {
+              p1PickOff--;
+              const slot1 = c.p;
+              op1PickAtOp2Pick.includes(slot1), c.d, getComponent(heldDropWrites[c.d]), hasPick(getComponent(heldDropWrites[c.d])), (c.r === void 0 || cancelledRemoves && cancelledRemoves.has(c)) && (slot1 == null || !pickComponents[slot1] || side !== 1 && op1PickAtOp2Pick.includes(slot1)) || outPickOff--;
             }
-            Ne = M.nextSibling();
+            p1pValid = p1Pick.nextSibling();
           }
-          ie = Ne && Be === ce ? M : null;
+          _p1Pick = p1pValid && p1k === k1Mid ? p1Pick : null;
         }
-        const ke = ce - P;
-        let Ge = ze(ke);
-        const rt = ke - he;
-        let Je = null;
+        const raw = k1Mid - p1PickOff;
+        let _p2Pick = ap2p(raw);
+        const k2Mid = raw - p2PickOff;
+        let _p2Drop = null;
         {
-          let Be, Re;
-          for (; Se && typeof (Be = A.getKey()) == "number"; ) {
-            Re = Be - be;
-            const Xe = A.getComponent(), Ke = o(Xe);
-            if (Re > rt) break;
-            if (Re === rt) {
-              if (!Ke) {
-                Je = A;
+          let p2dk, op2Mid;
+          for (; p2dValid && typeof (p2dk = p2Drop.getKey()) == "number"; ) {
+            op2Mid = p2dk - p2DropOff;
+            const c = p2Drop.getComponent(), hd2 = hasDrop(c);
+            if (op2Mid > k2Mid) break;
+            if (op2Mid === k2Mid) {
+              if (!hd2) {
+                _p2Drop = p2Drop;
                 break;
               }
               {
-                if (D === 0 && Oe) {
-                  Je = A;
+                if (side === 0 && hd1) {
+                  _p2Drop = p2Drop;
                   break;
                 }
-                const Ve = Ge && O(Ge.getComponent());
-                if (D === 0 && Ve) break;
+                const hp2 = _p2Pick && hasPick(_p2Pick.getComponent());
+                if (side === 0 && hp2) break;
               }
             }
-            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++;
+            if (hd2) {
+              const slot2 = c.d;
+              op1PickAtOp2Pick[slot2], c.i === void 0 && (cancelledOp2[slot2] || op1PickAtOp2Pick[slot2] != null && side !== 1) ? (cancelledOp2[slot2] || op1PickAtOp2Pick[slot2] != null && side === 0) && (p2DropOff++, outDropOff--) : p2DropOff++;
             }
-            Se = A.nextSibling();
+            p2dValid = p2Drop.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, X) && He++, k.ascend();
+        const descend = k2Mid + p2DropOff + outPickOff + outDropOff;
+        assert(descend >= 0, "trying to descend to a negative index"), w2.descend(descend), hd1 && (_p1Pick = _p2Pick = _p2Drop = null, p1DropOff++), writeOp1Drop(_p1Pick, p1Drop, _p2Pick, _p2Drop, w2, removed2) && outDropOff++, w2.ascend();
       } else {
-        let ie;
-        for (; Ne && (ie = M.getKey(), typeof ie != "string" || !(ie > S || ie === S)); ) Ne = M.nextSibling();
-        const Oe = Ne && ie === S ? M : null, ce = ze(S);
-        let ke;
-        for (; Se && (ke = A.getKey(), typeof ke != "string" || !(ke > S || ke === S)); ) Se = A.nextSibling();
-        const Ge = Se && ke === S ? A : null;
-        k.descend(S), Q(Oe, B, ce, Ge, k, X), k.ascend();
+        let p1k;
+        for (; p1pValid && (p1k = p1Pick.getKey(), typeof p1k != "string" || !(p1k > key || p1k === key)); ) p1pValid = p1Pick.nextSibling();
+        const _p1Pick = p1pValid && p1k === key ? p1Pick : null, _p2Pick = ap2p(key);
+        let p2dk;
+        for (; p2dValid && (p2dk = p2Drop.getKey(), typeof p2dk != "string" || !(p2dk > key || p2dk === key)); ) p2dValid = p2Drop.nextSibling();
+        const _p2Drop = p2dValid && p2dk === key ? p2Drop : null;
+        w2.descend(key), writeOp1Drop(_p1Pick, p1Drop, _p2Pick, _p2Drop, w2, removed2), w2.ascend();
       }
-      return ze.end(), Ye && M.ascend(), Te && A.ascend(), fe;
-    }(me, me.clone(), _e, _e.clone(), oe, null), m) return {
+      return ap2p.end(), p1pDidDescend && p1Pick.ascend(), p2dDidDescend && p2Drop.ascend(), droppedHere;
+    }, "writeOp1Drop"))(r1, r1.clone(), r2, r2.clone(), w, null), conflict) return {
       ok: !1,
-      conflict: m
+      conflict
     };
-    oe.reset();
-    const Me = (Q, M, B) => Q.traverse(M, (U, A) => {
-      U.d != null && B(U.d, Q, A);
-    });
-    (g.length || re.length) && (Me(_e, oe, (Q, M, 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 (Me(Q, null, (M, B) => {
-        Ee[M] = B.clone();
-      }), te.forEach((M) => {
-        M && Me(s.readCursor(M.get()), null, (B, U) => {
-          Ee[B] = U.clone();
+    w.reset();
+    const eachDrop = /* @__PURE__ */ __name((r, w2, fn) => r.traverse(w2, (c, w3) => {
+      c.d != null && fn(c.d, r, w3);
+    }), "eachDrop");
+    (cancelledOp2.length || heldPickWrites.length) && (eachDrop(r2, w, (slot2, r, w2) => {
+      cancelledOp2[slot2] && !discardedOp2Drop[slot2] && w2.write("r", !0), heldPickWrites[slot2] && w2.mergeTree(heldPickWrites[slot2].get());
+    }), w.reset());
+    const heldOutDropRead = [], heldOutDropWrites = [];
+    if ((heldDropWrites.length || cancelledOp2.length) && !conflict) {
+      const rOut = cursor_js_1.readCursor(shallowCloneOp(w.get()));
+      if (eachDrop(rOut, null, (slotOut, r) => {
+        heldOutDropRead[slotOut] = r.clone();
+      }), heldDropWrites.forEach((hdw) => {
+        hdw && eachDrop(cursor_js_1.readCursor(hdw.get()), null, (slotOut, r) => {
+          heldOutDropRead[slotOut] = r.clone();
         });
-      }), function M(B, U, A, k, X, Y) {
-        const ee = a(U);
-        if (ee && O(ee)) if (ee.p != null) {
-          const P = ee.p;
-          Ee[P].getPath(), A = Ee[P], k = $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(), k.mergeTree(x.get()), A = s.readCursor(x.get()));
+      }), (/* @__PURE__ */ __name(function writeHeldOp2Drop(p2Drop, outPick, outDrop, w2, parentC, removedOut) {
+        const coutp = getComponent(outPick);
+        if (coutp && hasPick(coutp)) if (coutp.p != null) {
+          const slot = coutp.p;
+          heldOutDropRead[slot].getPath(), outDrop = heldOutDropRead[slot], w2 = heldOutDropWrites[slot] = cursor_js_1.writeCursor();
+        } else coutp.r !== void 0 && (outDrop = null);
+        else hasDrop(getComponent(outDrop)) && (outDrop = null);
+        const c2 = p2Drop.getComponent();
+        if (c2) {
+          let slot2;
+          if ((slot2 = c2.d) != null) {
+            const _w = heldDropWrites[slot2];
+            _w && (_w.get(), w2.mergeTree(_w.get()), outDrop = cursor_js_1.readCursor(_w.get()));
           }
         }
-        let de = 0, le = 0;
-        const ye = s.advancer(U, 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++;
+        let outPickOff = 0, outDropOff = 0;
+        const oPickAdv = cursor_js_1.advancer(outPick, void 0, (k, c) => {
+          hasPick(c) && outPickOff--;
+        }), oDropAdv = cursor_js_1.advancer(outDrop, (k, c) => hasDrop(c) ? -(k - outDropOff) - 1 : k - outDropOff, (k, c) => {
+          hasDrop(c) && outDropOff++;
         });
-        for (const P of B) if (typeof P == "number") {
-          const x = ye(P), he = P + de, be = q(he), We = he + le;
-          k.descend(We), M(B, x, be, k), k.ascend();
-        } else k.descend(P), M(B, ye(P), q(P), k), k.ascend();
-        ye.end(), q.end();
-      }(_e, Q, Q.clone(), oe), oe.reset(), m) return {
+        for (const o2dk of p2Drop) if (typeof o2dk == "number") {
+          const _outPick = oPickAdv(o2dk), rmid = o2dk + outPickOff, _outDrop = oDropAdv(rmid), rfinal = rmid + outDropOff;
+          w2.descend(rfinal), writeHeldOp2Drop(p2Drop, _outPick, _outDrop, w2), w2.ascend();
+        } else w2.descend(o2dk), writeHeldOp2Drop(p2Drop, oPickAdv(o2dk), oDropAdv(o2dk), w2), w2.ascend();
+        oPickAdv.end(), oDropAdv.end();
+      }, "writeHeldOp2Drop"))(r2, rOut, rOut.clone(), w), w.reset(), conflict) return {
         ok: !1,
-        conflict: m
+        conflict
       };
-      if (oe.get(), $e.length) {
-        const M = $e.map((U) => U ? U.get() : null), B = s.readCursor(tt(oe.get()));
-        if (Me(B, oe, (U, A, k) => {
-          const X = M[U];
-          X && (k.mergeTree(X), M[U] = null);
-        }), M.find((U) => U)) {
-          const U = s.writeCursor(), A = s.writeCursor();
-          let k = 0, X = 0;
-          M.forEach((Y) => {
-            Y != null && Me(s.readCursor(Y), null, (ee) => {
-              const fe = Le[ee];
-              U.writeMove(C[fe].getPath(), $[fe].getPath(), k++);
-              const de = se[fe];
-              de && de.forEach((le) => {
-                g[le] || D !== 1 && K[le] != null || A.writeMove(T[le].getPath(), p[le].getPath(), X++);
+      if (w.get(), heldOutDropWrites.length) {
+        const heldOutDropContent = heldOutDropWrites.map((w2) => w2 ? w2.get() : null), rOut2 = cursor_js_1.readCursor(shallowCloneOp(w.get()));
+        if (eachDrop(rOut2, w, (slotOut, r, w2) => {
+          const data = heldOutDropContent[slotOut];
+          data && (w2.mergeTree(data), heldOutDropContent[slotOut] = null);
+        }), heldOutDropContent.find((x) => x)) {
+          const w1 = cursor_js_1.writeCursor(), w2 = cursor_js_1.writeCursor();
+          let nextSlot1 = 0, nextSlot2 = 0;
+          heldOutDropContent.forEach((data) => {
+            data != null && eachDrop(cursor_js_1.readCursor(data), null, (c) => {
+              const slot1 = outputSlotMap[c];
+              w1.writeMove(heldOp1PickByOp1[slot1].getPath(), heldOp1DropByOp1[slot1].getPath(), nextSlot1++);
+              const slot2s = op1PicksOp2DropSlots[slot1];
+              slot2s && slot2s.forEach((slot2) => {
+                cancelledOp2[slot2] || side !== 1 && op1PickAtOp2Pick[slot2] != null || w2.writeMove(heldOp2PickByOp2[slot2].getPath(), heldOp2DropByOp2[slot2].getPath(), nextSlot2++);
               });
             });
-          }), m = {
-            type: d.ConflictType.BLACKHOLE,
-            op1: U.get(),
-            op2: A.get()
+          }), conflict = {
+            type: types_js_1.ConflictType.BLACKHOLE,
+            op1: w1.get(),
+            op2: w2.get()
           };
         }
       }
     }
-    return m ? {
+    return conflict ? {
       ok: !1,
-      conflict: m
+      conflict
     } : {
       ok: !0,
-      result: oe.get()
+      result: w.get()
     };
   }
-  const gt = (r) => {
-    const u = new Error("Transform detected write conflict");
-    throw u.conflict = r, u.type = u.name = "writeConflict", u;
-  };
-  function Dt(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();
-  }, At = (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)];
+  __name(tryTransform, "tryTransform");
+  const throwConflictErr = /* @__PURE__ */ __name((conflict) => {
+    const err = new Error("Transform detected write conflict");
+    throw err.conflict = conflict, err.type = err.name = "writeConflict", err;
+  }, "throwConflictErr");
+  function transform(op1, op2, side) {
+    const res = tryTransform(op1, op2, side);
+    if (res.ok) return res.result;
+    throwConflictErr(res.conflict);
+  }
+  __name(transform, "transform");
+  const opThatRemovesDE = /* @__PURE__ */ __name((op) => {
+    const w = cursor_js_1.writeCursor();
+    return cursor_js_1.readCursor(op).traverse(w, (c, w2) => {
+      (hasDrop(c) || getEditType(c)) && w2.write("r", !0);
+    }), w.get();
+  }, "opThatRemovesDE"), resolveConflict = /* @__PURE__ */ __name((conflict, side) => {
+    const { type: type2, op1, op2 } = conflict;
+    switch (type2) {
+      case types_js_1.ConflictType.DROP_COLLISION:
+        return side === "left" ? [null, opThatRemovesDE(op2)] : [opThatRemovesDE(op1), null];
+      case types_js_1.ConflictType.RM_UNEXPECTED_CONTENT:
+        let op1HasRemove = !1;
+        return cursor_js_1.readCursor(op1).traverse(null, (c) => {
+          c.r !== void 0 && (op1HasRemove = !0);
+        }), op1HasRemove ? [null, opThatRemovesDE(op2)] : [opThatRemovesDE(op1), null];
+      case types_js_1.ConflictType.BLACKHOLE:
+        return [opThatRemovesDE(op1), opThatRemovesDE(op2)];
       default:
-        throw Error("Unrecognised conflict: " + y);
+        throw Error("Unrecognised conflict: " + type2);
     }
-  };
-  function _t(r, u, y, D) {
-    let m = null;
+  }, "resolveConflict");
+  function transformWithConflictsPred(allowConflict, op1, op2, side) {
+    let r2Aggregate = null;
     for (; ; ) {
-      const C = nt(u, y, D);
-      if (C.ok) return ne(m, C.result);
+      const res = tryTransform(op1, op2, side);
+      if (res.ok) return compose(r2Aggregate, res.result);
       {
-        const { conflict: $ } = C;
-        r($) || gt($);
-        const [T, p] = At($, D);
-        u = ne(H(u), T), y = ne(H(y), p), m = ne(m, p);
+        const { conflict } = res;
+        allowConflict(conflict) || throwConflictErr(conflict);
+        const [r1, r2] = resolveConflict(conflict, side);
+        op1 = compose(normalize(op1), r1), op2 = compose(normalize(op2), r2), r2Aggregate = compose(r2Aggregate, r2);
       }
     }
   }
-})(Ct);
-(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];
-    } });
-  } : 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);
+  __name(transformWithConflictsPred, "transformWithConflictsPred");
+})(json1_release);
+(function(exports) {
+  var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+    k2 === void 0 && (k2 = k), Object.defineProperty(o, k2, { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+      return m[k];
+    }, "get") });
+  } : function(o, m, k, k2) {
+    k2 === void 0 && (k2 = k), o[k2] = m[k];
+  }), __exportStar = commonjsGlobal && commonjsGlobal.__exportStar || function(m, exports2) {
+    for (var p in m) p !== "default" && !exports2.hasOwnProperty(p) && __createBinding(exports2, m, p);
   };
-  Object.defineProperty(n, "__esModule", { value: !0 }), t(Ct, 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 Ht {
+  Object.defineProperty(exports, "__esModule", { value: !0 }), __exportStar(json1_release, exports);
+  var cursor_js_1 = cursor;
+  Object.defineProperty(exports, "ReadCursor", { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+    return cursor_js_1.ReadCursor;
+  }, "get") }), Object.defineProperty(exports, "WriteCursor", { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+    return cursor_js_1.WriteCursor;
+  }, "get") });
+  var types_1 = types;
+  Object.defineProperty(exports, "ConflictType", { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+    return types_1.ConflictType;
+  }, "get") });
+})(dist$1);
+const _UnitDrawingService = class _UnitDrawingService {
   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());
+    __publicField(this, "drawingManagerData", {});
+    __publicField(this, "_oldDrawingManagerData", {});
+    __publicField(this, "_focusDrawings", []);
+    __publicField(this, "_remove$", new Subject());
+    __publicField(this, "remove$", this._remove$.asObservable());
+    __publicField(this, "_add$", new Subject());
+    __publicField(this, "add$", this._add$.asObservable());
+    __publicField(this, "_update$", new Subject());
+    __publicField(this, "update$", this._update$.asObservable());
+    __publicField(this, "_order$", new Subject());
+    __publicField(this, "order$", this._order$.asObservable());
+    __publicField(this, "_group$", new Subject());
+    __publicField(this, "group$", this._group$.asObservable());
+    __publicField(this, "_ungroup$", new Subject());
+    __publicField(this, "ungroup$", this._ungroup$.asObservable());
+    __publicField(this, "_refreshTransform$", new Subject());
+    __publicField(this, "refreshTransform$", this._refreshTransform$.asObservable());
+    __publicField(this, "_visible$", new Subject());
+    __publicField(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);
+    __publicField(this, "_focus$", new Subject());
+    __publicField(this, "focus$", this._focus$.asObservable());
+    __publicField(this, "_featurePluginUpdate$", new Subject());
+    __publicField(this, "featurePluginUpdate$", this._featurePluginUpdate$.asObservable());
+    __publicField(this, "_featurePluginAdd$", new Subject());
+    __publicField(this, "featurePluginAdd$", this._featurePluginAdd$.asObservable());
+    __publicField(this, "_featurePluginRemove$", new Subject());
+    __publicField(this, "featurePluginRemove$", this._featurePluginRemove$.asObservable());
+    __publicField(this, "_featurePluginOrderUpdate$", new Subject());
+    __publicField(this, "featurePluginOrderUpdate$", this._featurePluginOrderUpdate$.asObservable());
+    __publicField(this, "_featurePluginGroupUpdate$", new Subject());
+    __publicField(this, "featurePluginGroupUpdate$", this._featurePluginGroupUpdate$.asObservable());
+    __publicField(this, "_featurePluginUngroupUpdate$", new Subject());
+    __publicField(this, "featurePluginUngroupUpdate$", this._featurePluginUngroupUpdate$.asObservable());
+    __publicField(this, "_visible", !0);
+    __publicField(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 = {};
   }
-  visibleNotification(e) {
-    this._visible$.next(e);
+  visibleNotification(visibleParams) {
+    this._visible$.next(visibleParams);
   }
-  refreshTransform(e) {
-    e.forEach((t) => {
-      const i = this._getCurrentBySearch(t);
-      i != null && (i.transform = t.transform, i.transforms = t.transforms, i.isMultiTransform = t.isMultiTransform);
-    }), this.refreshTransformNotification(e);
+  refreshTransform(updateParams) {
+    updateParams.forEach((updateParam) => {
+      const param = this._getCurrentBySearch(updateParam);
+      param != null && (param.transform = updateParam.transform, param.transforms = updateParam.transforms, param.isMultiTransform = updateParam.isMultiTransform);
+    }), this.refreshTransformNotification(updateParams);
   }
-  getDrawingDataForUnit(e) {
-    return this.drawingManagerData[e];
+  getDrawingDataForUnit(unitId) {
+    return this.drawingManagerData[unitId];
   }
-  removeDrawingDataForUnit(e) {
-    const t = this.drawingManagerData[e];
-    if (t == null)
+  removeDrawingDataForUnit(unitId) {
+    const subUnits = this.drawingManagerData[unitId];
+    if (subUnits == 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 });
+    delete this.drawingManagerData[unitId];
+    const drawings = [];
+    Object.keys(subUnits).forEach((subUnitId) => {
+      const subUnit = subUnits[subUnitId];
+      (subUnit == null ? void 0 : subUnit.data) != null && Object.keys(subUnit.data).forEach((drawingId) => {
+        drawings.push({ unitId, subUnitId, drawingId });
       });
-    }), i.length > 0 && this.removeNotification(i);
-  }
-  registerDrawingData(e, t) {
-    this.drawingManagerData[e] = t;
-  }
-  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);
+    }), drawings.length > 0 && this.removeNotification(drawings);
+  }
+  registerDrawingData(unitId, data) {
+    this.drawingManagerData[unitId] = data;
+  }
+  initializeNotification(unitId) {
+    const drawings = [], data = this.drawingManagerData[unitId];
+    data != null && (Object.keys(data).forEach((subUnitId) => {
+      this._establishDrawingMap(unitId, subUnitId);
+      const subUnitData = data[subUnitId];
+      Object.keys(subUnitData.data).forEach((drawingId) => {
+        const drawing = subUnitData.data[drawingId];
+        drawing.unitId = unitId, drawing.subUnitId = subUnitId, drawings.push(drawing);
       });
-    }), t.length > 0 && this.addNotification(t));
+    }), drawings.length > 0 && this.addNotification(drawings));
   }
-  getDrawingData(e, t) {
-    return this._getDrawingData(e, t);
+  getDrawingData(unitId, subUnitId) {
+    return this._getDrawingData(unitId, subUnitId);
   }
   // Use in doc only.
-  setDrawingData(e, t, i) {
-    this.drawingManagerData[e][t].data = i;
-  }
-  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);
+  setDrawingData(unitId, subUnitId, data) {
+    this.drawingManagerData[unitId][subUnitId].data = data;
+  }
+  getBatchAddOp(insertParams) {
+    const objects = [], ops = [], invertOps = [];
+    insertParams.forEach((insertParam) => {
+      const { op: op2, invertOp: invertOp2 } = this._addByParam(insertParam);
+      objects.push({ unitId: insertParam.unitId, subUnitId: insertParam.subUnitId, drawingId: insertParam.drawingId }), ops.push(op2), invertOps.push(invertOp2);
     });
-    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 };
-  }
-  getBatchRemoveOp(e) {
-    const t = [], i = [];
-    e.forEach((E) => {
-      const { op: W, invertOp: O } = this._removeByParam(E);
-      t.push(W), i.push(O);
+    const op = ops.reduce(dist$1.type.compose, null), invertOp = invertOps.reduce(dist$1.type.compose, null), { unitId, subUnitId } = insertParams[0];
+    return { undo: invertOp, redo: op, unitId, subUnitId, objects };
+  }
+  getBatchRemoveOp(removeParams) {
+    const ops = [], invertOps = [];
+    removeParams.forEach((removeParam) => {
+      const { op: op2, invertOp: invertOp2 } = this._removeByParam(removeParam);
+      ops.push(op2), invertOps.push(invertOp2);
     });
-    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 };
-  }
-  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 op = ops.reduce(dist$1.type.compose, null), invertOp = invertOps.reduce(dist$1.type.compose, null), { unitId, subUnitId } = removeParams[0];
+    return { undo: invertOp, redo: op, unitId, subUnitId, objects: removeParams };
+  }
+  getBatchUpdateOp(updateParams) {
+    const objects = [], ops = [], invertOps = [];
+    updateParams.forEach((updateParam) => {
+      const { op: op2, invertOp: invertOp2 } = this._updateByParam(updateParam);
+      objects.push({ unitId: updateParam.unitId, subUnitId: updateParam.subUnitId, drawingId: updateParam.drawingId }), ops.push(op2), invertOps.push(invertOp2);
     });
-    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 op = ops.reduce(dist$1.type.compose, null), invertOp = invertOps.reduce(dist$1.type.compose, null), { unitId, subUnitId } = updateParams[0];
+    return { undo: invertOp, redo: op, unitId, subUnitId, objects };
   }
-  removeNotification(e) {
-    this._remove$.next(e);
+  removeNotification(removeParams) {
+    this._remove$.next(removeParams);
   }
-  addNotification(e) {
-    this._add$.next(e);
+  addNotification(insertParams) {
+    this._add$.next(insertParams);
   }
-  updateNotification(e) {
-    this._update$.next(e);
+  updateNotification(updateParams) {
+    this._update$.next(updateParams);
   }
-  orderNotification(e) {
-    this._order$.next(e);
+  orderNotification(orderParams) {
+    this._order$.next(orderParams);
   }
-  groupUpdateNotification(e) {
-    this._group$.next(e);
+  groupUpdateNotification(groupParams) {
+    this._group$.next(groupParams);
   }
-  ungroupUpdateNotification(e) {
-    this._ungroup$.next(e);
+  ungroupUpdateNotification(groupParams) {
+    this._ungroup$.next(groupParams);
   }
-  refreshTransformNotification(e) {
-    this._refreshTransform$.next(e);
+  refreshTransformNotification(refreshParams) {
+    this._refreshTransform$.next(refreshParams);
   }
-  getGroupDrawingOp(e) {
-    const t = [], { unitId: i, subUnitId: s } = e[0].parent;
-    e.forEach((a) => {
-      t.push(this._getGroupDrawingOp(a));
+  getGroupDrawingOp(groupParams) {
+    const ops = [], { unitId, subUnitId } = groupParams[0].parent;
+    groupParams.forEach((groupParam) => {
+      ops.push(this._getGroupDrawingOp(groupParam));
     });
-    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 op = ops.reduce(dist$1.type.compose, null);
+    return { undo: dist$1.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: groupParams };
   }
-  getUngroupDrawingOp(e) {
-    const t = [], { unitId: i, subUnitId: s } = e[0].parent;
-    e.forEach((a) => {
-      t.push(this._getUngroupDrawingOp(a));
+  getUngroupDrawingOp(groupParams) {
+    const ops = [], { unitId, subUnitId } = groupParams[0].parent;
+    groupParams.forEach((groupParam) => {
+      ops.push(this._getUngroupDrawingOp(groupParam));
     });
-    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 op = ops.reduce(dist$1.type.compose, null);
+    return { undo: dist$1.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: groupParams };
   }
-  getDrawingsByGroup(e) {
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    if (this.getDrawingByParam({ unitId: t, subUnitId: i, drawingId: s }) == null)
+  getDrawingsByGroup(groupParam) {
+    const { unitId, subUnitId, drawingId } = groupParam;
+    if (this.getDrawingByParam({ unitId, subUnitId, drawingId }) == 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;
-  }
-  _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 drawings = this._getDrawingData(unitId, subUnitId), children = [];
+    return Object.keys(drawings).forEach((key) => {
+      const drawing = drawings[key];
+      drawing.groupId === drawingId && children.push(drawing);
+    }), children;
+  }
+  _getGroupDrawingOp(groupParam) {
+    const { parent, children } = groupParam, { unitId: groupUnitId, subUnitId: groupSubUnitId, drawingId: groupDrawingId } = parent, ops = [];
+    ops.push(
+      dist$1.insertOp([groupUnitId, groupSubUnitId, "data", groupDrawingId], parent)
     );
-    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 }))
+    let maxChildIndex = Number.NEGATIVE_INFINITY;
+    return children.forEach((child) => {
+      const { unitId, subUnitId, drawingId } = child, index = this._hasDrawingOrder({ unitId, subUnitId, drawingId });
+      maxChildIndex = Math.max(maxChildIndex, index), ops.push(
+        ...this._getUpdateParamCompareOp(child, this.getDrawingByParam({ unitId, subUnitId, drawingId }))
       );
-    }), 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);
-  }
-  _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 }))
+    }), maxChildIndex === Number.NEGATIVE_INFINITY && (maxChildIndex = this._getDrawingOrder(groupUnitId, groupSubUnitId).length), ops.push(
+      dist$1.insertOp([groupUnitId, groupSubUnitId, "order", maxChildIndex], groupDrawingId)
+    ), ops.reduce(dist$1.type.compose, null);
+  }
+  _getUngroupDrawingOp(groupParam) {
+    const { parent, children } = groupParam, { unitId: groupUnitId, subUnitId: groupSubUnitId, drawingId: groupDrawingId } = parent, ops = [];
+    return children.forEach((child) => {
+      const { unitId, subUnitId, drawingId } = child;
+      ops.push(
+        ...this._getUpdateParamCompareOp(child, this.getDrawingByParam({ unitId, subUnitId, drawingId }))
       );
-    }), 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);
+    }), ops.push(
+      dist$1.removeOp([groupUnitId, groupSubUnitId, "data", groupDrawingId], !0)
+    ), ops.push(
+      dist$1.removeOp([groupUnitId, groupSubUnitId, "order", this._getDrawingOrder(groupUnitId, groupSubUnitId).indexOf(groupDrawingId)], !0)
+    ), ops.reduce(dist$1.type.compose, null);
   }
-  applyJson1(e, t, i) {
-    this._establishDrawingMap(e, t), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = F.type.apply(this.drawingManagerData, i);
+  applyJson1(unitId, subUnitId, jsonOp) {
+    this._establishDrawingMap(unitId, subUnitId), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = dist$1.type.apply(this.drawingManagerData, jsonOp);
   }
   // private _fillMissingFields(jsonOp: JSONOp) {
   //     if (jsonOp == null) {
@@ -1676,163 +1714,163 @@ class Ht {
   //         }
   //     }
   // }
-  featurePluginUpdateNotification(e) {
-    this._featurePluginUpdate$.next(e);
+  featurePluginUpdateNotification(updateParams) {
+    this._featurePluginUpdate$.next(updateParams);
   }
-  featurePluginOrderUpdateNotification(e) {
-    this._featurePluginOrderUpdate$.next(e);
+  featurePluginOrderUpdateNotification(drawingOrderUpdateParam) {
+    this._featurePluginOrderUpdate$.next(drawingOrderUpdateParam);
   }
-  featurePluginAddNotification(e) {
-    this._featurePluginAdd$.next(e);
+  featurePluginAddNotification(insertParams) {
+    this._featurePluginAdd$.next(insertParams);
   }
-  featurePluginRemoveNotification(e) {
-    this._featurePluginRemove$.next(e);
+  featurePluginRemoveNotification(removeParams) {
+    this._featurePluginRemove$.next(removeParams);
   }
-  featurePluginGroupUpdateNotification(e) {
-    this._featurePluginGroupUpdate$.next(e);
+  featurePluginGroupUpdateNotification(groupParams) {
+    this._featurePluginGroupUpdate$.next(groupParams);
   }
-  featurePluginUngroupUpdateNotification(e) {
-    this._featurePluginUngroupUpdate$.next(e);
+  featurePluginUngroupUpdateNotification(groupParams) {
+    this._featurePluginUngroupUpdate$.next(groupParams);
   }
-  getDrawingByParam(e) {
-    return this._getCurrentBySearch(e);
+  getDrawingByParam(param) {
+    return this._getCurrentBySearch(param);
   }
-  getOldDrawingByParam(e) {
-    return this._getOldBySearch(e);
+  getOldDrawingByParam(param) {
+    return this._getOldBySearch(param);
   }
-  getDrawingOKey(e) {
-    const [t, i, s] = e.split("#-#");
-    return this._getCurrentBySearch({ unitId: t, subUnitId: i, drawingId: s });
+  getDrawingOKey(oKey) {
+    const [unitId, subUnitId, drawingId] = oKey.split("#-#");
+    return this._getCurrentBySearch({ unitId, subUnitId, drawingId });
   }
-  focusDrawing(e) {
-    if (e == null) {
+  focusDrawing(params) {
+    if (params == null) {
       this._focusDrawings = [], this._focus$.next([]);
       return;
     }
-    const t = [];
-    e.forEach((i) => {
-      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 drawingParams = [];
+    params.forEach((param) => {
+      var _a2;
+      const { unitId, subUnitId, drawingId } = param, item = (_a2 = this._getDrawingData(unitId, subUnitId)) == null ? void 0 : _a2[drawingId];
+      item != null && drawingParams.push(item);
+    }), drawingParams.length > 0 && (this._focusDrawings = drawingParams, this._focus$.next(drawingParams));
   }
   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);
-    }), e;
+    const drawingParams = [];
+    return this._focusDrawings.forEach((param) => {
+      var _a2;
+      const { unitId, subUnitId, drawingId } = param, item = (_a2 = this._getDrawingData(unitId, subUnitId)) == null ? void 0 : _a2[drawingId];
+      item != null && drawingParams.push(item);
+    }), drawingParams;
   }
-  getDrawingOrder(e, t) {
-    return this._getDrawingOrder(e, t);
+  getDrawingOrder(unitId, subUnitId) {
+    return this._getDrawingOrder(unitId, subUnitId);
   }
   // Use in doc only.
-  setDrawingOrder(e, t, i) {
-    this.drawingManagerData[e][t].order = i;
+  setDrawingOrder(unitId, subUnitId, order) {
+    this.drawingManagerData[unitId][subUnitId].order = order;
   }
-  orderUpdateNotification(e) {
-    this._order$.next(e);
+  orderUpdateNotification(orderParams) {
+    this._order$.next(orderParams);
   }
-  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)
+  getForwardDrawingsOp(orderParams) {
+    const { unitId, subUnitId, drawingIds } = orderParams, ops = [], orders = this.getDrawingOrder(unitId, subUnitId), newIds = [...drawingIds];
+    drawingIds.forEach((drawingId) => {
+      const index = this._hasDrawingOrder({ unitId, subUnitId, drawingId });
+      if (index === -1 || index === orders.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 op2 = dist$1.moveOp([unitId, subUnitId, "order", index], [unitId, subUnitId, "order", index + 1]);
+      ops.push(op2), newIds.includes(orders[index + 1]) || newIds.push(orders[index + 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 } };
-  }
-  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 op = ops.reduce(dist$1.type.compose, null);
+    return { undo: dist$1.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: { ...orderParams, drawingIds: newIds } };
+  }
+  getBackwardDrawingOp(orderParams) {
+    const { unitId, subUnitId, drawingIds } = orderParams, ops = [], orders = this.getDrawingOrder(unitId, subUnitId), newIds = [...drawingIds];
+    drawingIds.forEach((drawingId) => {
+      const index = this._hasDrawingOrder({ unitId, subUnitId, drawingId });
+      if (index === -1 || index === 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 op2 = dist$1.moveOp([unitId, subUnitId, "order", index], [unitId, subUnitId, "order", index - 1]);
+      ops.push(op2), newIds.includes(orders[index - 1]) || newIds.push(orders[index - 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 } };
-  }
-  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, R = F.moveOp([t, i, "order", this._getDrawingOrder(t, i).indexOf(c)], [t, i, "order", h]);
-      E.push(R), l.includes(a[h]) || l.push(a[h]);
+    const op = ops.reduce(dist$1.type.compose, null);
+    return { undo: dist$1.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: { ...orderParams, drawingIds: newIds } };
+  }
+  getFrontDrawingsOp(orderParams) {
+    const { unitId, subUnitId, drawingIds } = orderParams, orderDrawingIds = this._getOrderFromSearchParams(unitId, subUnitId, drawingIds), newIds = [...drawingIds], orders = this.getDrawingOrder(unitId, subUnitId), ops = [];
+    orderDrawingIds.forEach((orderDrawingId) => {
+      const { drawingId } = orderDrawingId, index = this._getDrawingCount(unitId, subUnitId) - 1, op2 = dist$1.moveOp([unitId, subUnitId, "order", this._getDrawingOrder(unitId, subUnitId).indexOf(drawingId)], [unitId, subUnitId, "order", index]);
+      ops.push(op2), newIds.includes(orders[index]) || newIds.push(orders[index]);
     });
-    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 } };
-  }
-  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 op = ops.reduce(dist$1.type.compose, null);
+    return { undo: dist$1.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: { ...orderParams, drawingIds: newIds } };
+  }
+  getBackDrawingsOp(orderParams) {
+    const { unitId, subUnitId, drawingIds } = orderParams, orderSearchParams = this._getOrderFromSearchParams(unitId, subUnitId, drawingIds, !0), newIds = [...drawingIds], orders = this.getDrawingOrder(unitId, subUnitId), ops = [];
+    orderSearchParams.forEach((orderSearchParam) => {
+      const { drawingId } = orderSearchParam, op2 = dist$1.moveOp([unitId, subUnitId, "order", this._getDrawingOrder(unitId, subUnitId).indexOf(drawingId)], [unitId, subUnitId, "order", 0]);
+      ops.push(op2), newIds.includes(orders[0]) || newIds.push(orders[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 op = ops.reduce(dist$1.type.compose, null);
+    return { undo: dist$1.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: { ...orderParams, drawingIds: newIds } };
   }
-  _getDrawingCount(e, t) {
-    return this.getDrawingOrder(e, t).length || 0;
+  _getDrawingCount(unitId, subUnitId) {
+    return this.getDrawingOrder(unitId, subUnitId).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 ? Ut : Nt);
+  _getOrderFromSearchParams(unitId, subUnitId, drawingIds, isDesc = !1) {
+    return drawingIds.map((drawingId) => {
+      const zIndex = this._hasDrawingOrder({ unitId, subUnitId, drawingId });
+      return { drawingId, zIndex };
+    }).sort(isDesc === !1 ? sortRules : sortRulesByDesc);
   }
-  _hasDrawingOrder(e) {
-    if (e == null)
+  _hasDrawingOrder(searchParam) {
+    if (searchParam == null)
       return -1;
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    return this._establishDrawingMap(t, i), this._getDrawingOrder(t, i).indexOf(s);
+    const { unitId, subUnitId, drawingId } = searchParam;
+    return this._establishDrawingMap(unitId, subUnitId), this._getDrawingOrder(unitId, subUnitId).indexOf(drawingId);
   }
-  _getCurrentBySearch(e) {
-    var d, l, a;
-    if (e == null)
+  _getCurrentBySearch(searchParam) {
+    var _a2, _b, _c;
+    if (searchParam == 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, subUnitId, drawingId } = searchParam;
+    return (_c = (_b = (_a2 = this.drawingManagerData[unitId]) == null ? void 0 : _a2[subUnitId]) == null ? void 0 : _b.data) == null ? void 0 : _c[drawingId];
   }
-  _getOldBySearch(e) {
-    var d, l, a;
-    if (e == null)
+  _getOldBySearch(searchParam) {
+    var _a2, _b, _c;
+    if (searchParam == 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, subUnitId, drawingId } = searchParam;
+    return (_c = (_b = (_a2 = this._oldDrawingManagerData[unitId]) == null ? void 0 : _a2[subUnitId]) == null ? void 0 : _b.data) == null ? void 0 : _c[drawingId];
   }
-  _establishDrawingMap(e, t, i) {
-    var s;
-    return this.drawingManagerData[e] || (this.drawingManagerData[e] = {}), this.drawingManagerData[e][t] || (this.drawingManagerData[e][t] = {
+  _establishDrawingMap(unitId, subUnitId, drawingId) {
+    var _a2;
+    return this.drawingManagerData[unitId] || (this.drawingManagerData[unitId] = {}), this.drawingManagerData[unitId][subUnitId] || (this.drawingManagerData[unitId][subUnitId] = {
       data: {},
       order: []
-    }), i == null ? null : (s = this.drawingManagerData[e][t].data) == null ? void 0 : s[i];
+    }), drawingId == null ? null : (_a2 = this.drawingManagerData[unitId][subUnitId].data) == null ? void 0 : _a2[drawingId];
   }
-  _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 };
+  _addByParam(insertParam) {
+    const { unitId, subUnitId, drawingId } = insertParam;
+    this._establishDrawingMap(unitId, subUnitId, drawingId);
+    const op1 = dist$1.insertOp([unitId, subUnitId, "data", drawingId], insertParam), op2 = dist$1.insertOp([unitId, subUnitId, "order", this._getDrawingOrder(unitId, subUnitId).length], drawingId), op = [op1, op2].reduce(dist$1.type.compose, null), invertOp = dist$1.type.invertWithDoc(op, this.drawingManagerData);
+    return { op, invertOp };
   }
-  _removeByParam(e) {
-    if (e == null)
+  _removeByParam(searchParam) {
+    if (searchParam == null)
       return { op: [], invertOp: [] };
-    const { unitId: t, subUnitId: i, drawingId: s } = e;
-    if (this._establishDrawingMap(t, i, s) == null)
+    const { unitId, subUnitId, drawingId } = searchParam;
+    if (this._establishDrawingMap(unitId, subUnitId, drawingId) == 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 op1 = dist$1.removeOp([unitId, subUnitId, "data", drawingId], !0), op2 = dist$1.removeOp([unitId, subUnitId, "order", this._getDrawingOrder(unitId, subUnitId).indexOf(drawingId)], !0), op = [op1, op2].reduce(dist$1.type.compose, null), invertOp = dist$1.type.invertWithDoc(op, this.drawingManagerData);
+    return { op, invertOp };
   }
-  _updateByParam(e) {
-    const { unitId: t, subUnitId: i, drawingId: s } = e, d = this._establishDrawingMap(t, i, s);
-    if (d == null)
+  _updateByParam(updateParam) {
+    const { unitId, subUnitId, drawingId } = updateParam, object = this._establishDrawingMap(unitId, subUnitId, drawingId);
+    if (object == 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 op = this._getUpdateParamCompareOp(updateParam, object).reduce(dist$1.type.compose, null), invertOp = dist$1.type.invertWithDoc(op, this.drawingManagerData);
+    return { op, invertOp };
   }
   // private _initializeDrawingData(updateParam: T, oldParam: T) {
   //     Object.keys(updateParam).forEach((key) => {
@@ -1841,22 +1879,22 @@ class Ht {
   //         }
   //     });
   // }
-  _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(newParam, oldParam) {
+    const { unitId, subUnitId, drawingId } = newParam, ops = [];
+    return Object.keys(newParam).forEach((key) => {
+      const newVal = newParam[key], oldVal = oldParam[key];
+      oldVal !== newVal && ops.push(
+        dist$1.replaceOp([unitId, subUnitId, "data", drawingId, key], oldVal, newVal)
       );
-    }), l;
+    }), ops;
   }
-  _getDrawingData(e, t) {
-    var i, s;
-    return ((s = (i = this.drawingManagerData[e]) == null ? void 0 : i[t]) == null ? void 0 : s.data) || {};
+  _getDrawingData(unitId, subUnitId) {
+    var _a2, _b;
+    return ((_b = (_a2 = this.drawingManagerData[unitId]) == null ? void 0 : _a2[subUnitId]) == null ? void 0 : _b.data) || {};
   }
-  _getDrawingOrder(e, t) {
-    var i, s;
-    return ((s = (i = this.drawingManagerData[e]) == null ? void 0 : i[t]) == null ? void 0 : s.order) || [];
+  _getDrawingOrder(unitId, subUnitId) {
+    var _a2, _b;
+    return ((_b = (_a2 = this.drawingManagerData[unitId]) == null ? void 0 : _a2[subUnitId]) == null ? void 0 : _b.order) || [];
   }
   getDrawingVisible() {
     return this._visible;
@@ -1864,80 +1902,84 @@ class Ht {
   getDrawingEditable() {
     return this._editable;
   }
-  setDrawingVisible(e) {
-    this._visible = e;
+  setDrawingVisible(visible) {
+    this._visible = visible;
   }
-  setDrawingEditable(e) {
-    this._editable = e;
+  setDrawingEditable(editable) {
+    this._editable = editable;
   }
+};
+__name(_UnitDrawingService, "UnitDrawingService");
+let UnitDrawingService = _UnitDrawingService;
+const _DrawingManagerService = class _DrawingManagerService extends UnitDrawingService {
+};
+__name(_DrawingManagerService, "DrawingManagerService");
+let DrawingManagerService = _DrawingManagerService;
+function getDrawingShapeKeyByDrawingSearch({ unitId, subUnitId, drawingId }, index) {
+  return typeof index == "number" ? `${unitId}#-#${subUnitId}#-#${drawingId}#-#${index}` : `${unitId}#-#${subUnitId}#-#${drawingId}`;
 }
-class Kt extends Ht {
-}
-function cn({ unitId: n, subUnitId: e, drawingId: t }, i) {
-  return typeof i == "number" ? `${n}#-#${e}#-#${t}#-#${i}` : `${n}#-#${e}#-#${t}`;
-}
-const un = async (n) => new Promise((e, t) => {
-  const i = new Image();
-  i.src = n, i.onload = () => {
-    e({
-      width: i.width,
-      height: i.height,
-      image: i
+__name(getDrawingShapeKeyByDrawingSearch, "getDrawingShapeKeyByDrawingSearch");
+const getImageSize = /* @__PURE__ */ __name(async (src) => new Promise((resolve, reject) => {
+  const image = new Image();
+  image.src = src, image.onload = () => {
+    resolve({
+      width: image.width,
+      height: image.height,
+      image
     });
-  }, i.onerror = (s) => {
-    t(s);
+  }, image.onerror = (error) => {
+    reject(error);
   };
-});
-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 Vt = It("core.image-io.service");
-class Ft {
+}), "getImageSize");
+var ImageSourceType = /* @__PURE__ */ ((ImageSourceType2) => (ImageSourceType2.URL = "URL", ImageSourceType2.UUID = "UUID", ImageSourceType2.BASE64 = "BASE64", ImageSourceType2))(ImageSourceType || {}), ImageUploadStatusType = /* @__PURE__ */ ((ImageUploadStatusType2) => (ImageUploadStatusType2.SUCCUSS = "0", ImageUploadStatusType2.ERROR_EXCEED_SIZE = "1", ImageUploadStatusType2.ERROR_IMAGE_TYPE = "2", ImageUploadStatusType2.ERROR_UPLOAD_COUNT_LIMIT = "3", ImageUploadStatusType2.ERROR_IMAGE = "4", ImageUploadStatusType2))(ImageUploadStatusType || {});
+const IImageIoService = createIdentifier("core.image-io.service"), _ImageIoService = class _ImageIoService {
   constructor() {
-    V(this, "_waitCount", 0);
-    V(this, "_change$", new we());
-    V(this, "change$", this._change$);
-    V(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;
+    __publicField(this, "_waitCount", 0);
+    __publicField(this, "_change$", new Subject());
+    __publicField(this, "change$", this._change$);
+    __publicField(this, "_imageSourceCache", /* @__PURE__ */ new Map());
+  }
+  setWaitCount(count) {
+    this._waitCount = count, this._change$.next(count);
+  }
+  getImageSourceCache(source, imageSourceType) {
+    if (imageSourceType === ImageSourceType.BASE64) {
+      const image = new Image();
+      return image.src = source, image;
     }
-    return this._imageSourceCache.get(e);
+    return this._imageSourceCache.get(source);
   }
-  addImageSourceCache(e, t, i) {
-    t === et.BASE64 || i == null || this._imageSourceCache.set(e, i);
+  addImageSourceCache(source, imageSourceType, imageSource) {
+    imageSourceType === ImageSourceType.BASE64 || imageSource == null || this._imageSourceCache.set(source, imageSource);
   }
-  async getImage(e) {
-    return Promise.resolve(e);
+  async getImage(imageId) {
+    return Promise.resolve(imageId);
   }
-  async saveImage(e) {
-    return new Promise((t, i) => {
-      if (!Wt.includes(e.type)) {
-        i(new Error(Ze.ERROR_IMAGE_TYPE)), this._decreaseWaiting();
+  async saveImage(imageFile) {
+    return new Promise((resolve, reject) => {
+      if (!DRAWING_IMAGE_ALLOW_IMAGE_LIST.includes(imageFile.type)) {
+        reject(new Error(ImageUploadStatusType.ERROR_IMAGE_TYPE)), this._decreaseWaiting();
         return;
       }
-      if (e.size > $t) {
-        i(new Error(Ze.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
+      if (imageFile.size > DRAWING_IMAGE_ALLOW_SIZE) {
+        reject(new Error(ImageUploadStatusType.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
         return;
       }
-      const s = new FileReader();
-      s.readAsDataURL(e), s.onload = (d) => {
-        var E;
-        const l = (E = d.target) == null ? void 0 : E.result;
-        if (l == null) {
-          i(new Error(Ze.ERROR_IMAGE)), this._decreaseWaiting();
+      const reader = new FileReader();
+      reader.readAsDataURL(imageFile), reader.onload = (evt) => {
+        var _a2;
+        const replaceSrc = (_a2 = evt.target) == null ? void 0 : _a2.result;
+        if (replaceSrc == null) {
+          reject(new Error(ImageUploadStatusType.ERROR_IMAGE)), this._decreaseWaiting();
           return;
         }
-        const a = kt.generateRandomId(6);
-        t({
-          imageId: a,
-          imageSourceType: et.BASE64,
-          source: l,
-          base64Cache: l,
-          status: Ze.SUCCUSS
+        const imageId = Tools.generateRandomId(6);
+        resolve({
+          imageId,
+          imageSourceType: ImageSourceType.BASE64,
+          source: replaceSrc,
+          base64Cache: replaceSrc,
+          status: ImageUploadStatusType.SUCCUSS
         }), this._decreaseWaiting();
       };
     });
@@ -1945,52 +1987,54 @@ class Ft {
   _decreaseWaiting() {
     this._waitCount -= 1, this._change$.next(this._waitCount);
   }
-}
-const dn = "__default_document_sub_component_id20231101__";
-var qt = /* @__PURE__ */ ((n) => (n[n.forward = 0] = "forward", n[n.backward = 1] = "backward", n[n.front = 2] = "front", n[n.back = 3] = "back", n))(qt || {}), zt = /* @__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))(zt || {});
-const Xt = It("univer.drawing-manager.service");
-var Yt = Object.defineProperty, Zt = Object.getOwnPropertyDescriptor, Jt = (n, e, t, i) => {
-  for (var s = i > 1 ? void 0 : i ? Zt(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 && Yt(e, t, s), s;
-}, Qt = (n, e) => (t, i) => e(t, i, n);
-const en = "DRAWING_PLUGIN";
-var ot;
-let wt = (ot = class extends Rt {
-  constructor(n, e) {
-    super(), this._config = n, this._injector = e;
-  }
-  onStarting(n) {
-    this._initDependencies(n);
-  }
-  _initDependencies(n) {
-    var i;
-    St([
-      [Vt, { useClass: Ft }],
-      [Xt, { useClass: Kt }]
-    ], (i = this._config) == null ? void 0 : i.override).forEach((s) => n.add(s));
-  }
-}, V(ot, "pluginName", en), ot);
-wt = Jt([
-  Qt(1, Tt(jt))
-], wt);
+};
+__name(_ImageIoService, "ImageIoService");
+let ImageIoService = _ImageIoService;
+const DEFAULT_DOCUMENT_SUB_COMPONENT_ID = "__default_document_sub_component_id20231101__";
+var ArrangeTypeEnum = /* @__PURE__ */ ((ArrangeTypeEnum2) => (ArrangeTypeEnum2[ArrangeTypeEnum2.forward = 0] = "forward", ArrangeTypeEnum2[ArrangeTypeEnum2.backward = 1] = "backward", ArrangeTypeEnum2[ArrangeTypeEnum2.front = 2] = "front", ArrangeTypeEnum2[ArrangeTypeEnum2.back = 3] = "back", ArrangeTypeEnum2))(ArrangeTypeEnum || {}), DrawingTypeEnum = /* @__PURE__ */ ((DrawingTypeEnum2) => (DrawingTypeEnum2[DrawingTypeEnum2.UNRECOGNIZED = -1] = "UNRECOGNIZED", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_IMAGE = 0] = "DRAWING_IMAGE", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_SHAPE = 1] = "DRAWING_SHAPE", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_CHART = 2] = "DRAWING_CHART", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_TABLE = 3] = "DRAWING_TABLE", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_SMART_ART = 4] = "DRAWING_SMART_ART", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_VIDEO = 5] = "DRAWING_VIDEO", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_GROUP = 6] = "DRAWING_GROUP", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_UNIT = 7] = "DRAWING_UNIT", DrawingTypeEnum2[DrawingTypeEnum2.DRAWING_DOM = 8] = "DRAWING_DOM", DrawingTypeEnum2))(DrawingTypeEnum || {});
+const IDrawingManagerService = createIdentifier("univer.drawing-manager.service");
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam");
+const PLUGIN_NAME = "DRAWING_PLUGIN";
+var _a;
+let UniverDrawingPlugin = (_a = class extends Plugin {
+  constructor(_config, _injector) {
+    super(), this._config = _config, this._injector = _injector;
+  }
+  onStarting() {
+    this._initDependencies();
+  }
+  _initDependencies() {
+    var _a2;
+    mergeOverrideWithDependencies([
+      [IImageIoService, { useClass: ImageIoService }],
+      [IDrawingManagerService, { useClass: DrawingManagerService }]
+    ], (_a2 = this._config) == null ? void 0 : _a2.override).forEach((d) => this._injector.add(d));
+  }
+}, __name(_a, "UniverDrawingPlugin"), __publicField(_a, "pluginName", PLUGIN_NAME), _a);
+UniverDrawingPlugin = __decorateClass([
+  __decorateParam(1, Inject(Injector))
+], UniverDrawingPlugin);
 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,
-  zt as DrawingTypeEnum,
-  Xt as IDrawingManagerService,
-  Vt as IImageIoService,
-  Ft as ImageIoService,
-  et as ImageSourceType,
-  Ze as ImageUploadStatusType,
-  Ht as UnitDrawingService,
-  wt as UniverDrawingPlugin,
-  cn as getDrawingShapeKeyByDrawingSearch,
-  un as getImageSize
+  ArrangeTypeEnum,
+  DEFAULT_DOCUMENT_SUB_COMPONENT_ID,
+  DRAWING_IMAGE_ALLOW_IMAGE_LIST,
+  DRAWING_IMAGE_ALLOW_SIZE,
+  DRAWING_IMAGE_COUNT_LIMIT,
+  DRAWING_IMAGE_HEIGHT_LIMIT,
+  DRAWING_IMAGE_WIDTH_LIMIT,
+  DrawingManagerService,
+  DrawingTypeEnum,
+  IDrawingManagerService,
+  IImageIoService,
+  ImageIoService,
+  ImageSourceType,
+  ImageUploadStatusType,
+  UnitDrawingService,
+  UniverDrawingPlugin,
+  getDrawingShapeKeyByDrawingSearch,
+  getImageSize
 };