@univerjs/drawing 0.5.4 → 0.5.5-experimental.20250123-34738ff

package/lib/es/index.js

@@ -1,123 +1,131 @@
-var Nt = Object.defineProperty;
-var Rt = (a, e, n) => e in a ? Nt(a, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : a[e] = n;
-var F = (a, e, n) => Rt(a, typeof e != "symbol" ? e + "" : e, n);
-import { sortRules as xt, sortRulesByDesc as Bt, createIdentifier as Wt, CommandType as Gt, ImageSourceType as at, ImageUploadStatusType as Qe, Tools as Lt, Inject as qt, Injector as Kt, Plugin as Ft, merge as Vt, mergeOverrideWithDependencies as Ht, IConfigService as zt, ICommandService as Xt, IImageIoService as Jt } from "@univerjs/core";
-import { IImageIoService as En, ImageSourceType as Dn, ImageUploadStatusType as Pn } from "@univerjs/core";
-import { Subject as ve } from "rxjs";
-const mn = 500, On = 500, wn = 10, Yt = 5 * 1024 * 1024, Zt = ["image/png", "image/jpeg", "image/jpg", "image/gif", "image/bmp"];
-var Ye = {}, et = {}, tt = {}, mt;
-function Qt() {
-  if (mt) return tt;
-  mt = 1, Object.defineProperty(tt, "__esModule", { value: !0 });
-  function a(t, r) {
-    if (Array.isArray(r))
+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 { sortRules, sortRulesByDesc, createIdentifier, CommandType, ImageSourceType, ImageUploadStatusType, Tools, Inject, Injector, Plugin, merge, mergeOverrideWithDependencies, IConfigService, ICommandService, IImageIoService } from "@univerjs/core";
+import { IImageIoService as IImageIoService2, ImageSourceType as ImageSourceType2, ImageUploadStatusType as ImageUploadStatusType2 } from "@univerjs/core";
+import { Subject } from "rxjs";
+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 dist$1 = {}, json1_release = {}, deepEqual = {}, hasRequiredDeepEqual;
+function requireDeepEqual() {
+  if (hasRequiredDeepEqual) return deepEqual;
+  hasRequiredDeepEqual = 1, Object.defineProperty(deepEqual, "__esModule", { value: !0 });
+  function eqObj(a, b) {
+    if (Array.isArray(b))
       return !1;
-    for (let u in t)
-      if (!n(t[u], r[u]))
+    for (let k in a)
+      if (!deepEqual$1(a[k], b[k]))
         return !1;
-    for (let u in r)
-      if (t[u] === void 0)
+    for (let k in b)
+      if (a[k] === void 0)
         return !1;
     return !0;
   }
-  function e(t, r) {
-    if (!Array.isArray(r) || t.length !== r.length)
+  __name(eqObj, "eqObj");
+  function eqArr(a, b) {
+    if (!Array.isArray(b) || a.length !== b.length)
       return !1;
-    for (let u = 0; u < t.length; u++)
-      if (!n(t[u], r[u]))
+    for (let i = 0; i < a.length; i++)
+      if (!deepEqual$1(a[i], b[i]))
         return !1;
     return !0;
   }
-  function n(t, r) {
-    return t === r ? !0 : t === null || r === null || typeof t != "object" || typeof r != "object" ? !1 : Array.isArray(t) ? e(t, r) : a(t, r);
+  __name(eqArr, "eqArr");
+  function deepEqual$1(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);
   }
-  return tt.default = n, tt;
+  return __name(deepEqual$1, "deepEqual$1"), deepEqual.default = deepEqual$1, deepEqual;
 }
-var nt = {}, Ot;
-function en() {
-  if (Ot) return nt;
-  Ot = 1, Object.defineProperty(nt, "__esModule", { value: !0 });
-  function a(e) {
-    if (e === null)
+__name(requireDeepEqual, "requireDeepEqual");
+var deepClone = {}, hasRequiredDeepClone;
+function requireDeepClone() {
+  if (hasRequiredDeepClone) return deepClone;
+  hasRequiredDeepClone = 1, Object.defineProperty(deepClone, "__esModule", { value: !0 });
+  function deepClone$1(old) {
+    if (old === null)
       return null;
-    if (Array.isArray(e))
-      return e.map(a);
-    if (typeof e == "object") {
-      const n = {};
-      for (let t in e)
-        n[t] = a(e[t]);
-      return n;
+    if (Array.isArray(old))
+      return old.map(deepClone$1);
+    if (typeof old == "object") {
+      const o = {};
+      for (let k in old)
+        o[k] = deepClone$1(old[k]);
+      return o;
     } else
-      return e;
+      return old;
   }
-  return nt.default = a, nt;
+  return __name(deepClone$1, "deepClone$1"), deepClone.default = deepClone$1, deepClone;
 }
-var lt = {}, wt;
-function Mt() {
-  return wt || (wt = 1, function(a) {
-    Object.defineProperty(a, "__esModule", { value: !0 }), a.eachChildOf = a.advancer = a.readCursor = a.writeCursor = a.WriteCursor = a.ReadCursor = a.isValidPathItem = void 0;
-    function e(_, s) {
-      if (!_)
-        throw new Error(s);
+__name(requireDeepClone, "requireDeepClone");
+var cursor = {}, hasRequiredCursor;
+function requireCursor() {
+  return hasRequiredCursor || (hasRequiredCursor = 1, 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);
     }
-    const n = (_) => _ != null && typeof _ == "object" && !Array.isArray(_), t = (_, s) => (
+    __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 _ == typeof s ? _ > s : typeof _ == "string" && typeof s == "number"
-    );
-    function r(_, s) {
-      for (let d in _) {
-        const h = d;
-        s.write(h, _[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]);
       }
     }
-    a.isValidPathItem = (_) => typeof _ == "number" || typeof _ == "string" && _ !== "__proto__";
-    class u {
-      constructor(s = null) {
-        this.parents = [], this.indexes = [], this.lcIdx = -1, this.idx = -1, this.container = s;
+    __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--, n(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 s = [];
-        let d = this.container, h = this.parents.length - 1, k = this.idx;
-        for (; k >= 0; )
-          s.unshift(d[k]), k === 0 ? (k = this.indexes[h * 2], d = this.parents[h--]) : k -= n(d[k - 1]) ? 2 : 1;
-        return s;
+        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 o extends u {
+    };
+    __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 s;
-        return this.container && this.container.length > this.idx + 1 && n(s = this.container[this.idx + 1]) ? s : null;
+        let c;
+        return this.container && this.container.length > this.idx + 1 && isObject(c = this.container[this.idx + 1]) ? c : null;
       }
       descendFirst() {
-        let s = this.idx + 1;
-        if (!this.container || s >= this.container.length || n(this.container[s]) && s + 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;
-        n(this.container[s]) && s++;
-        const d = this.container[s];
-        return Array.isArray(d) ? (this.indexes.push(this.idx), this.parents.push(this.container), this.indexes.push(s), this.idx = 0, this.container = d) : this.idx = s, !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 s = this.indexes[this.indexes.length - 1] + 1, d = this.parents[this.parents.length - 1];
-        return s >= d.length ? !1 : (e(!isNaN(s)), this.indexes[this.indexes.length - 1] = s, this.container = d[s], !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(s, d, h, k) {
-        this.container = s, this.idx = d, this.parents = h.slice(), this.indexes = k.slice();
+      _init(_container, _idx, _parents, _indexes) {
+        this.container = _container, this.idx = _idx, this.parents = _parents.slice(), this.indexes = _indexes.slice();
       }
       clone() {
-        const s = new o();
-        return s._init(this.container, this.idx, this.parents, this.indexes), s;
+        const c = new _ReadCursor();
+        return c._init(this.container, this.idx, this.parents, this.indexes), c;
       }
       *[Symbol.iterator]() {
         if (this.descendFirst()) {
@@ -130,49 +138,51 @@ function Mt() {
       // TODO(cleanup): Consider moving these functions out of cursor, since
       // they're really just helper methods.
       // It'd be really nice to do this using generators.
-      traverse(s, d) {
-        const h = this.getComponent();
-        h && d(h, s);
-        for (const k of this)
-          s && s.descend(k), this.traverse(s, d), s && s.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(s, d) {
-        this.traverse(s, (h, k) => {
-          h.p != null && d(h.p, k);
+      eachPick(w, fn) {
+        this.traverse(w, (c, w2) => {
+          c.p != null && fn(c.p, w2);
         });
       }
-      eachDrop(s, d) {
-        this.traverse(s, (h, k) => {
-          h.d != null && d(h.d, k);
+      eachDrop(w, fn) {
+        this.traverse(w, (c, w2) => {
+          c.d != null && fn(c.d, w2);
         });
       }
-    }
-    a.ReadCursor = o;
-    class l extends u {
-      constructor(s = null) {
-        super(s), this.pendingDescent = [], this._op = s;
+    };
+    __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 s = 0; s < this.pendingDescent.length; s++) {
-          const d = this.pendingDescent[s];
-          let h = this.idx + 1;
-          if (h < this.container.length && n(this.container[h]) && h++, e(h === this.container.length || !n(this.container[h])), h === this.container.length)
-            this.container.push(d), this.idx = h;
-          else if (this.container[h] === d)
-            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 k = this.container.splice(h, this.container.length - h);
-              this.container.push(k), 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(t(d, this.container[this.lcIdx][0])), h = this.lcIdx + 1, this.lcIdx = -1); h < this.container.length && t(d, this.container[h][0]); )
-              h++;
-            if (this.indexes.push(h), this.idx = 0, h < this.container.length && this.container[h][0] === d)
-              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 k = [d];
-              this.container.splice(h, 0, k), this.container = k;
+              const child = [k];
+              this.container.splice(i, 0, child), this.container = child;
             }
           }
         }
@@ -186,442 +196,455 @@ function Mt() {
       // components.
       getComponent() {
         this.flushDescent();
-        const s = this.idx + 1;
-        if (s < this.container.length && n(this.container[s]))
-          return this.container[s];
+        const i = this.idx + 1;
+        if (i < this.container.length && isObject(this.container[i]))
+          return this.container[i];
         {
-          const d = {};
-          return this.container.splice(s, 0, d), d;
+          const component = {};
+          return this.container.splice(i, 0, component), component;
         }
       }
-      write(s, d) {
-        const h = this.getComponent();
-        e(h[s] == null || h[s] === d, "Internal consistency error: Overwritten component. File a bug"), h[s] = d;
+      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(s) {
-        if (!a.isValidPathItem(s))
+      descend(key) {
+        if (!exports.isValidPathItem(key))
           throw Error("Invalid JSON key");
-        this.pendingDescent.push(s);
+        this.pendingDescent.push(key);
       }
-      descendPath(s) {
-        return this.pendingDescent.push(...s), this;
+      descendPath(path) {
+        return this.pendingDescent.push(...path), this;
       }
       ascend() {
         this.pendingDescent.length ? this.pendingDescent.pop() : super.ascend();
       }
-      mergeTree(s, d = r) {
-        if (s === null)
+      mergeTree(data, mergeFn = copyAll) {
+        if (data === null)
           return;
-        if (e(Array.isArray(s)), s === this._op)
+        if (assert(Array.isArray(data)), data === this._op)
           throw Error("Cannot merge into my own tree");
-        const h = this.lcIdx, k = this.parents.length;
-        let Y = 0;
-        for (let pe = 0; pe < s.length; pe++) {
-          const Z = s[pe];
-          typeof Z == "string" || typeof Z == "number" ? (Y++, this.descend(Z)) : Array.isArray(Z) ? this.mergeTree(Z, d) : typeof Z == "object" && d(Z, 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 (; Y--; )
+        for (; depth--; )
           this.ascend();
-        this.lcIdx = this.parents.length === k ? h : -1;
+        this.lcIdx = this.parents.length === oldDepth ? _lcIdx : -1;
       }
-      at(s, d) {
-        this.descendPath(s), d(this);
-        for (let h = 0; h < s.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(s, d, h) {
-        return this.at(s, () => this.write(d, h)), this.reset(), this;
+      writeAtPath(path, key, value) {
+        return this.at(path, () => this.write(key, value)), this.reset(), this;
       }
-      writeMove(s, d, h = 0) {
-        return this.writeAtPath(s, "p", h).writeAtPath(d, "d", h);
+      writeMove(path1, path2, slot = 0) {
+        return this.writeAtPath(path1, "p", slot).writeAtPath(path2, "d", slot);
       }
       getPath() {
-        const s = super.getPath();
-        return s.push(...this.pendingDescent), s;
+        const path = super.getPath();
+        return path.push(...this.pendingDescent), path;
       }
-    }
-    a.WriteCursor = l, a.writeCursor = () => new l(), a.readCursor = (_) => new o(_);
-    function E(_, s, d) {
-      let h, k;
-      k = h = _ ? _.descendFirst() : !1;
-      function Y(pe) {
-        let Z;
-        for (; k; ) {
-          const Ce = Z = _.getKey();
-          if (pe != null) {
-            let Ge = !1;
-            if (s && typeof Ce == "number" && (Z = s(Ce, _.getComponent()), Z < 0 && (Z = ~Z, Ge = !0)), t(Z, pe))
+    };
+    __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 (Z === pe && !Ge)
-              return _;
+            if (k2_ === ktarget && !skip)
+              return r;
           }
-          d && typeof Z == "number" && d(Z, _.getComponent()), k = _.nextSibling();
+          listAdv && typeof k2_ == "number" && listAdv(k2_, r.getComponent()), valid = r.nextSibling();
         }
         return null;
       }
-      return Y.end = () => {
-        h && _.ascend();
-      }, Y;
+      return __name(adv, "adv"), adv.end = () => {
+        didDescend && r.ascend();
+      }, adv;
     }
-    a.advancer = E;
-    function x(_, s, d) {
-      let h, k, Y, pe;
-      for (h = k = _ && _.descendFirst(), Y = pe = s && s.descendFirst(); h || Y; ) {
-        let Z = h ? _.getKey() : null, Ce = Y ? s.getKey() : null;
-        Z !== null && Ce !== null && (t(Ce, Z) ? Ce = null : Z !== Ce && (Z = null)), d(Z == null ? Ce : Z, Z != null ? _ : null, Ce != null ? s : null), Z != null && h && (h = _.nextSibling()), Ce != null && Y && (Y = s.nextSibling());
+    __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());
       }
-      k && _.ascend(), pe && s.ascend();
+      descended1 && r1.ascend(), descended2 && r2.ascend();
     }
-    a.eachChildOf = x;
-  }(lt)), lt;
+    __name(eachChildOf, "eachChildOf"), exports.eachChildOf = eachChildOf;
+  }(cursor)), cursor;
 }
-var ut = {}, bt;
-function St() {
-  return bt || (bt = 1, function(a) {
-    Object.defineProperty(a, "__esModule", { value: !0 }), a.ConflictType = void 0, function(e) {
-      e[e.RM_UNEXPECTED_CONTENT = 1] = "RM_UNEXPECTED_CONTENT", e[e.DROP_COLLISION = 2] = "DROP_COLLISION", e[e.BLACKHOLE = 3] = "BLACKHOLE";
-    }(a.ConflictType || (a.ConflictType = {}));
-  }(ut)), ut;
+__name(requireCursor, "requireCursor");
+var types = {}, hasRequiredTypes;
+function requireTypes() {
+  return hasRequiredTypes || (hasRequiredTypes = 1, 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)), types;
 }
-var Fe = {}, Ve = {}, vt;
-function pt() {
-  return vt || (vt = 1, Object.defineProperty(Ve, "__esModule", { value: !0 }), Ve.uniToStrPos = Ve.strPosToUni = void 0, Ve.strPosToUni = (a, e = a.length) => {
-    let n = 0, t = 0;
-    for (; t < e; t++) {
-      const r = a.charCodeAt(t);
-      r >= 55296 && r <= 57343 && (n++, t++);
+__name(requireTypes, "requireTypes");
+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 (t !== e)
+    if (i !== strOffset)
       throw Error("Invalid offset - splits unicode bytes");
-    return t - n;
-  }, Ve.uniToStrPos = (a, e) => {
-    let n = 0;
-    for (; e > 0; e--) {
-      const t = a.charCodeAt(n);
-      n += t >= 55296 && t <= 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 n;
-  }), Ve;
+    return pos;
+  }), unicount;
 }
-var dt = {}, Ct;
-function ht() {
-  return Ct || (Ct = 1, function(a) {
-    Object.defineProperty(a, "__esModule", { value: !0 }), a.uniSlice = a.dlen = a.eachOp = void 0;
-    const e = pt(), n = (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 y = null;
-      for (let v = 0; v < f.length; v++) {
-        const L = f[v];
-        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 (a.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 y == "number")
+            if (typeof last == "number")
               throw Error("Adjacent skip components should be combined");
             break;
         }
-        y = L;
+        last = c;
       }
-      if (typeof y == "number")
+      if (typeof last == "number")
         throw Error("Op has a trailing skip");
-    };
-    function t(f, y) {
-      let v = 0, L = 0;
-      for (let z = 0; z < f.length; z++) {
-        const q = f[z];
-        switch (y(q, v, L), typeof q) {
+    }, "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":
-            v += a.dlen(q.d);
+            prePos += exports.dlen(c.d);
             break;
           case "string":
-            L += e.strPosToUni(q);
+            postPos += unicount_1.strPosToUni(c);
             break;
           case "number":
-            v += q, L += q;
+            prePos += c, postPos += c;
             break;
         }
       }
     }
-    a.eachOp = t;
-    function r(f, y) {
-      const v = [], L = l(v);
-      return t(f, (z, q, Ee) => {
-        L(y(z, q, Ee));
-      }), s(v);
+    __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 u = (f) => f, o = (f) => r(f, u);
-    a.dlen = (f) => typeof f == "number" ? f : e.strPosToUni(f);
-    const l = (f) => (y) => {
-      if (!(!y || y.d === 0 || y.d === "")) if (f.length === 0)
-        f.push(y);
-      else if (typeof y == typeof f[f.length - 1])
-        if (typeof y == "object") {
-          const v = f[f.length - 1];
-          v.d = typeof v.d == "string" && typeof y.d == "string" ? v.d + y.d : a.dlen(v.d) + a.dlen(y.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] += y;
+          op[op.length - 1] += component;
       else
-        f.push(y);
-    }, E = (f) => typeof f == "number" ? f : typeof f == "string" ? e.strPosToUni(f) : typeof f.d == "number" ? f.d : e.strPosToUni(f.d);
-    a.uniSlice = (f, y, v) => {
-      const L = e.uniToStrPos(f, y), z = v == null ? 1 / 0 : e.uniToStrPos(f, v);
-      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 x = (f, y, v) => typeof f == "number" ? v == null ? f - y : Math.min(f, v) - y : a.uniSlice(f, y, v), _ = (f) => {
-      let y = 0, v = 0;
-      return { take: (q, Ee) => {
-        if (y === f.length)
-          return q === -1 ? null : q;
-        const de = f[y];
-        let ne;
-        if (typeof de == "number")
-          return q === -1 || de - v <= q ? (ne = de - v, ++y, v = 0, ne) : (v += q, q);
-        if (typeof de == "string") {
-          if (q === -1 || Ee === "i" || e.strPosToUni(de.slice(v)) <= q)
-            return ne = de.slice(v), ++y, v = 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 le = v + e.uniToStrPos(de.slice(v), q);
-            return ne = de.slice(v, le), v = le, ne;
+            const offset2 = offset + unicount_1.uniToStrPos(c.slice(offset), n);
+            return part = c.slice(offset, offset2), offset = offset2, part;
           }
         } else {
-          if (q === -1 || Ee === "d" || a.dlen(de.d) - v <= q)
-            return ne = { d: x(de.d, v) }, ++y, v = 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 le = x(de.d, v, v + q);
-            return v += q, { d: le };
+            let result = dslice(c.d, offset, offset + n);
+            return offset += n, { d: result };
           }
         }
-      }, peek: () => f[y] };
-    }, s = (f) => (f.length > 0 && typeof f[f.length - 1] == "number" && f.pop(), f);
-    function d(f, y, v) {
-      if (v !== "left" && v !== "right")
-        throw Error("side (" + v + ") must be 'left' or 'right'");
-      n(f), n(y);
-      const L = [], z = l(L), { take: q, peek: Ee } = _(f);
-      for (let ne = 0; ne < y.length; ne++) {
-        const le = y[ne];
-        let ge, De;
-        switch (typeof le) {
+      }, "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 = le; ge > 0; )
-              De = q(ge, "i"), z(De), typeof De != "string" && (ge -= E(De));
+            for (length = c2; length > 0; )
+              c1 = take(length, "i"), append(c1), typeof c1 != "string" && (length -= componentLength(c1));
             break;
           case "string":
-            v === "left" && typeof Ee() == "string" && z(q(-1)), z(e.strPosToUni(le));
+            side === "left" && typeof peek() == "string" && append(take(-1)), append(unicount_1.strPosToUni(c2));
             break;
           case "object":
-            for (ge = a.dlen(le.d); ge > 0; )
-              switch (De = q(ge, "i"), typeof De) {
+            for (length = exports.dlen(c2.d); length > 0; )
+              switch (c1 = take(length, "i"), typeof c1) {
                 case "number":
-                  ge -= De;
+                  length -= c1;
                   break;
                 case "string":
-                  z(De);
+                  append(c1);
                   break;
                 case "object":
-                  ge -= a.dlen(De.d);
+                  length -= exports.dlen(c1.d);
               }
             break;
         }
       }
-      let de;
-      for (; de = q(-1); )
-        z(de);
-      return s(L);
+      let c;
+      for (; c = take(-1); )
+        append(c);
+      return trim(newOp);
     }
-    function h(f, y) {
-      n(f), n(y);
-      const v = [], L = l(v), { take: z } = _(f);
-      for (let Ee = 0; Ee < y.length; Ee++) {
-        const de = y[Ee];
-        let ne, le;
-        switch (typeof de) {
+    __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 = de; ne > 0; )
-              le = z(ne, "d"), L(le), typeof le != "object" && (ne -= E(le));
+            for (length = component; length > 0; )
+              chunk = take(length, "d"), append(chunk), typeof chunk != "object" && (length -= componentLength(chunk));
             break;
           case "string":
-            L(de);
+            append(component);
             break;
           case "object":
-            ne = a.dlen(de.d);
-            let ge = 0;
-            for (; ge < ne; )
-              switch (le = z(ne - ge, "d"), typeof le) {
+            length = exports.dlen(component.d);
+            let offset = 0;
+            for (; offset < length; )
+              switch (chunk = take(length - offset, "d"), typeof chunk) {
                 case "number":
-                  L({ d: x(de.d, ge, ge + le) }), ge += le;
+                  append({ d: dslice(component.d, offset, offset + chunk) }), offset += chunk;
                   break;
                 case "string":
-                  ge += e.strPosToUni(le);
+                  offset += unicount_1.strPosToUni(chunk);
                   break;
                 case "object":
-                  L(le);
+                  append(chunk);
               }
             break;
         }
       }
-      let q;
-      for (; q = z(-1); )
-        L(q);
-      return s(v);
+      let c;
+      for (; c = take(-1); )
+        append(c);
+      return trim(result);
     }
-    const k = (f, y) => {
-      let v = 0;
-      for (let L = 0; L < y.length && f > v; L++) {
-        const z = y[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": {
-            v += z;
+            pos += c;
             break;
           }
           case "string":
-            const q = e.strPosToUni(z);
-            v += q, f += q;
+            const offset = unicount_1.strPosToUni(c);
+            pos += offset, cursor2 += offset;
             break;
           case "object":
-            f -= Math.min(a.dlen(z.d), f - v);
+            cursor2 -= Math.min(exports.dlen(c.d), cursor2 - pos);
             break;
         }
       }
-      return f;
-    }, Y = (f, y) => typeof f == "number" ? k(f, y) : f.map((v) => k(v, y));
-    function pe(f, y, v) {
-      return r(f, (L, z) => typeof L == "object" && typeof L.d == "number" ? { d: v.slice(y, 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 Z(f) {
-      return r(f, (y) => {
-        switch (typeof y) {
+    __name(makeInvertible, "makeInvertible");
+    function invert(op) {
+      return mapOp(op, (c) => {
+        switch (typeof c) {
           case "object":
-            if (typeof y.d == "number")
+            if (typeof c.d == "number")
               throw Error("Cannot invert text op: Deleted characters missing from operation. makeInvertible must be called first.");
-            return y.d;
+            return c.d;
           // delete -> insert
           case "string":
-            return { d: y };
+            return { d: c };
           // Insert -> delete
           case "number":
-            return y;
+            return c;
         }
       });
     }
-    function Ce(f) {
-      return r(f, (y) => typeof y == "object" && typeof y.d == "string" ? { d: e.strPosToUni(y.d) } : y);
+    __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 Ge(f) {
-      let y = !0;
-      return t(f, (v) => {
-        typeof v == "object" && typeof v.d == "number" && (y = !1);
-      }), y;
+    __name(stripInvertible, "stripInvertible");
+    function isInvertible(op) {
+      let invertible = !0;
+      return eachOp(op, (c) => {
+        typeof c == "object" && typeof c.d == "number" && (invertible = !1);
+      }), invertible;
     }
-    function me(f) {
+    __name(isInvertible, "isInvertible");
+    function makeType(ropeImpl) {
       return {
         name: "text-unicode",
         uri: "http://sharejs.org/types/text-unicode",
-        trim: s,
-        normalize: o,
-        checkOp: n,
+        trim,
+        normalize,
+        checkOp,
         /** Create a new text snapshot.
          *
          * @param {string} initial - initial snapshot data. Optional. Defaults to ''.
          * @returns {Snap} Initial document snapshot object
          */
-        create(y = "") {
-          if (typeof y != "string")
+        create(initial = "") {
+          if (typeof initial != "string")
             throw Error("Initial data must be a string");
-          return f.create(y);
+          return ropeImpl.create(initial);
         },
         /** Apply an operation to a document snapshot
          */
-        apply(y, v) {
-          n(v);
-          const L = f.builder(y);
-          for (let z = 0; z < v.length; z++) {
-            const q = v[z];
-            switch (typeof q) {
+        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(q);
+                builder.skip(component);
                 break;
               case "string":
-                L.append(q);
+                builder.append(component);
                 break;
               case "object":
-                L.del(a.dlen(q.d));
+                builder.del(exports.dlen(component.d));
                 break;
             }
           }
-          return L.build();
+          return builder.build();
         },
-        transform: d,
-        compose: h,
-        transformPosition: k,
-        transformSelection: Y,
-        isInvertible: Ge,
-        makeInvertible(y, v) {
-          return pe(y, v, f);
+        transform,
+        compose,
+        transformPosition,
+        transformSelection,
+        isInvertible,
+        makeInvertible(op, doc) {
+          return makeInvertible(op, doc, ropeImpl);
         },
-        stripInvertible: Ce,
-        invert: Z,
-        invertWithDoc(y, v) {
-          return Z(pe(y, v, f));
+        stripInvertible,
+        invert,
+        invertWithDoc(op, doc) {
+          return invert(makeInvertible(op, doc, ropeImpl));
         },
-        isNoop: (y) => y.length === 0
+        isNoop: /* @__PURE__ */ __name((op) => op.length === 0, "isNoop")
       };
     }
-    a.default = me;
-  }(dt)), dt;
+    __name(makeType, "makeType"), exports.default = makeType;
+  }(type)), type;
 }
-var rt = {}, It;
-function tn() {
-  if (It) return rt;
-  It = 1, Object.defineProperty(rt, "__esModule", { value: !0 });
-  const a = ht(), e = pt();
-  function n(t, r) {
+__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: t,
+      get: getSnapshot,
       // Returns the number of characters in the string
       getLength() {
-        return t().length;
+        return getSnapshot().length;
       },
       // Insert the specified text at the given position in the document
-      insert(u, o, l) {
-        const E = e.strPosToUni(t(), u);
-        return r([E, o], l);
+      insert(pos, text, callback) {
+        const uniPos = unicount_1.strPosToUni(getSnapshot(), pos);
+        return submitOp([uniPos, text], callback);
       },
-      remove(u, o, l) {
-        const E = e.strPosToUni(t(), u);
-        return r([E, { d: o }], l);
+      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(u) {
-        a.eachOp(u, (o, l, E) => {
-          switch (typeof o) {
+      _onOp(op) {
+        type_1.eachOp(op, (component, prePos, postPos) => {
+          switch (typeof component) {
             case "string":
-              this.onInsert && this.onInsert(E, o);
+              this.onInsert && this.onInsert(postPos, component);
               break;
             case "object":
-              const x = a.dlen(o.d);
-              this.onRemove && this.onRemove(E, x);
+              const dl = type_1.dlen(component.d);
+              this.onRemove && this.onRemove(postPos, dl);
           }
         });
       },
@@ -629,1051 +652,1071 @@ function tn() {
       onRemove: null
     };
   }
-  return rt.default = n, n.provides = { text: !0 }, rt;
+  return __name(api$1, "api$1"), api.default = api$1, api$1.provides = { text: !0 }, api;
 }
-var Et;
-function nn() {
-  return Et || (Et = 1, function(a) {
-    var e = Fe.__createBinding || (Object.create ? function(d, h, k, Y) {
-      Y === void 0 && (Y = k), Object.defineProperty(d, Y, { enumerable: !0, get: function() {
-        return h[k];
-      } });
-    } : function(d, h, k, Y) {
-      Y === void 0 && (Y = k), d[Y] = h[k];
-    }), n = Fe.__setModuleDefault || (Object.create ? function(d, h) {
-      Object.defineProperty(d, "default", { enumerable: !0, value: h });
-    } : function(d, h) {
-      d.default = h;
-    }), t = Fe.__importStar || function(d) {
-      if (d && d.__esModule) return d;
-      var h = {};
-      if (d != null) for (var k in d) Object.hasOwnProperty.call(d, k) && e(h, d, k);
-      return n(h, d), h;
-    }, r = Fe.__importDefault || function(d) {
-      return d && d.__esModule ? d : { default: d };
+__name(requireApi, "requireApi");
+var hasRequiredDist$1;
+function requireDist$1() {
+  return hasRequiredDist$1 || (hasRequiredDist$1 = 1, function(exports) {
+    var __createBinding = dist.__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 = dist.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: !0, value: v });
+    } : function(o, v) {
+      o.default = v;
+    }), __importStar = dist.__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 = dist.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
     };
-    Object.defineProperty(a, "__esModule", { value: !0 }), a.type = a.remove = a.insert = void 0;
-    const u = pt(), o = t(ht()), l = r(tn()), E = {
-      create(d) {
-        return d;
+    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(d) {
-        return d;
+      toString(s) {
+        return s;
       },
-      builder(d) {
-        if (typeof d != "string")
-          throw Error("Invalid document snapshot: " + d);
-        const h = [];
+      builder(oldDoc) {
+        if (typeof oldDoc != "string")
+          throw Error("Invalid document snapshot: " + oldDoc);
+        const newDoc = [];
         return {
-          skip(k) {
-            let Y = u.uniToStrPos(d, k);
-            if (Y > d.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(d.slice(0, Y)), d = d.slice(Y);
+            newDoc.push(oldDoc.slice(0, offset)), oldDoc = oldDoc.slice(offset);
           },
-          append(k) {
-            h.push(k);
+          append(s) {
+            newDoc.push(s);
           },
-          del(k) {
-            d = d.slice(u.uniToStrPos(d, k));
+          del(n) {
+            oldDoc = oldDoc.slice(unicount_1.uniToStrPos(oldDoc, n));
           },
           build() {
-            return h.join("") + d;
+            return newDoc.join("") + oldDoc;
           }
         };
       },
-      slice: o.uniSlice
-    }, x = o.default(E), _ = Object.assign(Object.assign({}, x), { api: l.default });
-    a.type = _, a.insert = (d, h) => h.length === 0 ? [] : d === 0 ? [h] : [d, h], a.remove = (d, h) => o.dlen(h) === 0 ? [] : d === 0 ? [{ d: h }] : [d, { d: h }];
-    var s = ht();
-    Object.defineProperty(a, "makeType", { enumerable: !0, get: function() {
-      return s.default;
-    } });
-  }(Fe)), Fe;
+      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;
 }
-var Dt;
-function rn() {
-  return Dt || (Dt = 1, function(a) {
-    var e = et.__importDefault || function(i) {
-      return i && i.__esModule ? i : {
-        default: i
+__name(requireDist$1, "requireDist$1");
+var hasRequiredJson1_release;
+function requireJson1_release() {
+  return hasRequiredJson1_release || (hasRequiredJson1_release = 1, function(exports) {
+    var __importDefault = json1_release.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : {
+        default: mod
       };
     };
-    Object.defineProperty(a, "__esModule", {
+    Object.defineProperty(exports, "__esModule", {
       value: !0
-    }), a.editOp = a.replaceOp = a.insertOp = a.moveOp = a.removeOp = a.type = void 0;
-    const n = e(Qt()), t = e(en()), r = Mt(), u = St();
-    function o(i, c) {
-      if (!i) throw new Error(c);
+    }), exports.editOp = exports.replaceOp = exports.insertOp = exports.moveOp = exports.removeOp = exports.type = void 0;
+    const deepEqual_js_1 = __importDefault(requireDeepEqual()), deepClone_js_1 = __importDefault(requireDeepClone()), cursor_js_1 = requireCursor(), types_js_1 = requireTypes();
+    function assert(pred, msg) {
+      if (!pred) throw new Error(msg);
     }
-    a.type = {
+    __name(assert, "assert"), exports.type = {
       name: "json1",
       uri: "http://sharejs.org/types/JSONv1",
-      readCursor: r.readCursor,
-      writeCursor: r.writeCursor,
-      create: (i) => i,
-      isNoop: (i) => i == null,
-      setDebug(i) {
+      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: Z,
-      checkValidOp: z,
-      normalize: q,
-      apply: Ee,
-      transformPosition: de,
-      compose: ne,
-      tryTransform: st,
-      transform: jt,
-      makeInvertible: De,
-      invert: le,
-      invertWithDoc: kt,
-      RM_UNEXPECTED_CONTENT: u.ConflictType.RM_UNEXPECTED_CONTENT,
-      DROP_COLLISION: u.ConflictType.DROP_COLLISION,
-      BLACKHOLE: u.ConflictType.BLACKHOLE,
-      transformNoConflict: (i, c, O) => yt(() => !0, i, c, O),
-      typeAllowingConflictsPred: (i) => Object.assign(Object.assign({}, a.type), {
-        transform: (c, O, D) => yt(i, c, O, D)
-      })
+      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")
     };
-    const l = (i) => i ? i.getComponent() : null;
-    function E(i) {
-      return i && typeof i == "object" && !Array.isArray(i);
+    const getComponent = /* @__PURE__ */ __name((r) => r ? r.getComponent() : null, "getComponent");
+    function isObject(o) {
+      return o && typeof o == "object" && !Array.isArray(o);
     }
-    const x = (i) => Array.isArray(i) ? i.slice() : i !== null && typeof i == "object" ? Object.assign({}, i) : i, _ = (i) => i && (i.p != null || i.r !== void 0), s = (i) => i && (i.d != null || i.i !== void 0);
-    function d(i, c) {
-      return o(i != null), typeof c == "number" ? (o(Array.isArray(i), "Invalid key - child is not an array"), (i = i.slice()).splice(c, 1)) : (o(E(i), "Invalid key - child is not an object"), delete (i = Object.assign({}, i))[c]), i;
+    __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;
     }
-    function h(i, c, O) {
-      return typeof c == "number" ? (o(i != null, "Container is missing for key"), o(Array.isArray(i), "Cannot use numerical key for object container"), o(i.length >= c, "Cannot insert into out of bounds index"), i.splice(c, 0, O)) : (o(E(i), "Cannot insert into missing item"), o(i[c] === void 0, "Trying to overwrite value at key. Your op needs to remove it first"), i[c] = O), O;
+    __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;
     }
-    a.removeOp = (i, c = !0) => r.writeCursor().writeAtPath(i, "r", c).get(), a.moveOp = (i, c) => r.writeCursor().writeMove(i, c).get(), a.insertOp = (i, c) => r.writeCursor().writeAtPath(i, "i", c).get(), a.replaceOp = (i, c, O) => r.writeCursor().at(i, (D) => {
-      D.write("r", c), D.write("i", O);
-    }).get(), a.editOp = (i, c, O, D = !1) => r.writeCursor().at(i, (w) => y(w, c, O, D)).get();
-    const k = (i, c) => i != null && (typeof c == "number" ? Array.isArray(i) : typeof i == "object"), Y = (i, c) => k(i, c) ? i[c] : void 0, pe = {};
-    function Z(i) {
-      let c = i.type ? i.type : i;
-      c.name && (pe[c.name] = c), c.uri && (pe[c.uri] = c);
+    __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);
     }
-    const Ce = (i) => {
-      const c = pe[i];
-      if (c) return c;
-      throw Error("Missing type: " + i);
-    };
-    Z(nn());
-    const Ge = (i, c) => i + c;
-    Z({
+    __name(registerSubtype, "registerSubtype");
+    const typeOrThrow = /* @__PURE__ */ __name((name) => {
+      const type2 = subtypes[name];
+      if (type2) return type2;
+      throw Error("Missing type: " + name);
+    }, "typeOrThrow");
+    registerSubtype(requireDist$1());
+    const add = /* @__PURE__ */ __name((a, b) => a + b, "add");
+    registerSubtype({
       name: "number",
-      apply: Ge,
-      compose: Ge,
-      invert: (i) => -i,
-      transform: (i) => i
+      apply: add,
+      compose: add,
+      invert: /* @__PURE__ */ __name((n) => -n, "invert"),
+      transform: /* @__PURE__ */ __name((a) => a, "transform")
     });
-    const me = (i) => i == null ? null : i.et ? Ce(i.et) : i.es ? pe["text-unicode"] : i.ena != null ? pe.number : null, f = (i) => i.es ? i.es : i.ena != null ? i.ena : i.e, y = (i, c, O, D = !1) => {
-      const [w, I] = typeof c == "string" ? [Ce(c), c] : [c, c.name];
-      !D && w.isNoop && w.isNoop(O) || (I === "number" ? i.write("ena", O) : I === "text-unicode" ? i.write("es", O) : (i.write("et", I), i.write("e", O)));
-    };
-    function v(i) {
-      o(typeof i == "number"), o(i >= 0), o(i === (0 | i));
+    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));
     }
-    function L(i) {
-      typeof i == "number" ? v(i) : o(typeof i == "string");
+    __name(checkNonNegInteger, "checkNonNegInteger");
+    function checkScalar(s) {
+      typeof s == "number" ? checkNonNegInteger(s) : assert(typeof s == "string");
     }
-    function z(i) {
-      if (i === null) return;
-      const c = /* @__PURE__ */ new Set(), O = /* @__PURE__ */ new Set(), D = (I) => {
-        let R = !0, $ = !1;
-        for (let p in I) {
-          const m = I[p];
-          if (R = !1, o(p === "p" || p === "r" || p === "d" || p === "i" || p === "e" || p === "es" || p === "ena" || p === "et", "Invalid component item '" + p + "'"), p === "p") v(m), o(!c.has(m)), c.add(m), o(I.r === void 0);
-          else if (p === "d") v(m), o(!O.has(m)), O.add(m), o(I.i === void 0);
-          else if (p === "e" || p === "es" || p === "ena") {
-            o(!$), $ = !0;
-            const b = me(I);
-            o(b, "Missing type in edit"), b.checkValidOp && b.checkValidOp(f(I));
+    __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));
           }
         }
-        o(!R);
-      }, w = (I, R, $) => {
-        if (!Array.isArray(I)) throw Error("Op must be null or a list");
-        if (I.length === 0) throw Error("Empty descent");
-        R || L(I[0]);
-        let p = 1, m = 0, b = 0;
-        for (let C = 0; C < I.length; C++) {
-          const N = I[C];
-          if (o(N != null), Array.isArray(N)) {
-            const B = w(N, !1);
-            if (m) {
-              const g = typeof b, S = typeof B;
-              g === S ? o(b < B, "descent keys are not in order") : o(g === "number" && S === "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 = B, m++, p = 3;
-          } else typeof N == "object" ? (o(p === 1, `Prev not scalar - instead ${p}`), D(N), p = 2) : (o(p !== 3), L(N), o(r.isValidPathItem(N), "Invalid path key"), p = 1);
+            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 o(m !== 1, "Operation makes multiple descents. Remove some []"), o(p === 2 || p === 3), I[0];
-      };
-      w(i, !0), o(c.size === O.size, "Mismatched picks and drops in op");
-      for (let I = 0; I < c.size; I++) o(c.has(I)), o(O.has(I));
+        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));
     }
-    function q(i) {
-      let c = 0, O = [];
-      const D = r.writeCursor();
-      return D.mergeTree(i, (w, I) => {
-        const R = me(w);
-        if (R) {
-          const p = f(w);
-          y(I, R, R.normalize ? R.normalize(p) : p);
+    __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 (w[p] !== void 0) {
-          const m = p === "p" || p === "d" ? ($ = w[p], O[$] == null && (O[$] = c++), O[$]) : w[p];
-          I.write(p, m);
+        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 $;
-      }), D.get();
+        var inSlot;
+      }), w.get();
     }
-    function Ee(i, c) {
-      if (z(c), c === null) return i;
-      const O = [];
-      return function D(w, I) {
-        let R = w, $ = 0, p = {
-          root: w
-        }, m = 0, b = p, C = "root";
-        function N() {
-          for (; m < $; m++) {
-            let B = I[m];
-            typeof B != "object" && (o(k(b, C)), b = b[C] = x(b[C]), C = B);
+    __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 (; $ < I.length; $++) {
-          const B = I[$];
-          if (Array.isArray(B)) {
-            const g = D(R, B);
-            g !== R && g !== void 0 && (N(), R = b[C] = g);
-          } else if (typeof B == "object") {
-            B.d != null ? (N(), R = h(b, C, O[B.d])) : B.i !== void 0 && (N(), R = h(b, C, B.i));
-            const g = me(B);
-            if (g) N(), R = b[C] = g.apply(R, f(B));
-            else if (B.e !== void 0) throw Error("Subtype " + B.et + " undefined");
-          } else R = Y(R, B);
+        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;
-      }(i = function D(w, I) {
-        const R = [];
-        let $ = 0;
-        for (; $ < I.length; $++) {
-          const C = I[$];
-          if (Array.isArray(C)) break;
-          typeof C != "object" && (R.push(w), w = Y(w, C));
+        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 C = I.length - 1; C >= $; C--) w = D(w, I[C]);
-        for (--$; $ >= 0; $--) {
-          const C = I[$];
-          if (typeof C != "object") {
-            const N = R.pop();
-            w = w === Y(N, C) ? N : w === void 0 ? d(N, C) : (m = C, b = w, (p = x(p = N))[m] = b, p);
-          } else _(C) && (o(w !== void 0, "Cannot pick up or remove undefined"), C.p != null && (O[C.p] = w), w = 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, m, b;
-        return w;
-      }(i, c), c);
+        var obj, k, v;
+        return subDoc;
+      }, "pick"))(snapshot, op), op);
     }
-    function de(i, c) {
-      i = i.slice(), z(c);
-      const O = r.readCursor(c);
-      let D, w, I = !1;
-      const R = [];
-      for (let p = 0; ; p++) {
-        const m = i[p], b = O.getComponent();
-        if (b && (b.r !== void 0 ? I = !0 : b.p != null && (I = !1, D = b.p, w = p)), p >= i.length) break;
-        let C = 0;
-        const N = r.advancer(O, void 0, (g, S) => {
-          _(S) && C++;
+    __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++;
         });
-        R.unshift(N);
-        const B = N(m);
-        if (typeof m == "number" && (i[p] -= C), !B) break;
+        advStack.unshift(pickAdv);
+        const hasNext = pickAdv(k);
+        if (typeof k == "number" && (path[i] -= pickOffset), !hasNext) break;
       }
-      if (R.forEach((p) => p.end()), I) return null;
-      const $ = () => {
-        let p = 0;
-        if (D != null) {
-          const m = O.getPath();
-          p = m.length, i = m.concat(i.slice(w));
+      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 < i.length; p++) {
-          const m = i[p], b = l(O), C = me(b);
-          if (C) {
-            const g = f(b);
-            C.transformPosition && (i[p] = C.transformPosition(i[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 N = 0;
-          const B = r.advancer(O, (g, S) => s(S) ? ~(g - N) : g - N, (g, S) => {
-            s(S) && N++;
-          })(m);
-          if (typeof m == "number" && (i[p] += N), !B) 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 ? O.eachDrop(null, (p) => {
-        p === D && $();
-      }) : $(), i;
+      }, "handleDrop");
+      return pickedAtSlot != null ? r.eachDrop(null, (slot) => {
+        slot === pickedAtSlot && handleDrop();
+      }) : handleDrop(), path;
     }
-    function ne(i, c) {
-      if (z(i), z(c), i == null) return c;
-      if (c == null) return i;
-      let O = 0;
-      const D = r.readCursor(i), w = r.readCursor(c), I = r.writeCursor(), R = [], $ = [], p = [], m = [], b = [], C = [], N = /* @__PURE__ */ new Set();
-      D.traverse(null, (g) => {
-        g.p != null && (p[g.p] = D.clone());
-      }), w.traverse(null, (g) => {
-        g.d != null && (m[g.d] = w.clone());
+    __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 B = r.writeCursor();
-      return function g(S, re, te, K, se, $e, we, ye) {
-        o(re || te);
-        const oe = l(re), Pe = l(te), Ae = !!Pe && Pe.r !== void 0, Le = !!oe && oe.i !== void 0, Te = oe ? oe.d : null, Ie = Pe ? Pe.p : null, Ne = ($e || Ae) && Ie == null;
-        if (Ie != null) K = m[Ie], we = $[Ie] = new r.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 T = l(K);
-          T && T.d != null && (K = null);
+          const c2d2 = getComponent(r2Drop);
+          c2d2 && c2d2.d != null && (r2Drop = null);
         }
-        const Q = l(K);
-        if (Te != null) if (S = p[Te], ye = R[Te] = new r.WriteCursor(), Ne) $e && !Ae && ye.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 T = b[Te] = O++;
-          we.write("d", T);
+          const slot = p1SlotMap[drop1Slot] = nextSlot++;
+          wd.write("d", slot);
         }
-        else if (oe && oe.i !== void 0) S = null;
+        else if (c1d && c1d.i !== void 0) r1Pick = null;
         else {
-          const T = l(S);
-          T && T.p != null && (S = null);
+          const c1p = getComponent(r1Pick);
+          c1p && c1p.p != null && (r1Pick = null);
         }
-        let A;
-        Le ? (o(se === void 0), A = oe.i) : A = se;
-        const W = (Ie == null ? !Le || $e || Ae : A === void 0) ? null : we.getComponent();
-        if (Ie != null) {
-          if (!(se !== void 0 || Le)) {
-            const T = Te != null ? b[Te] : O++;
-            C[Ie] = T, ye.write("p", T);
+        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 Ae && (Le || se !== void 0 || (Pe.r, ye.write("r", Pe.r)));
-        const M = Ne ? null : me(oe), P = me(Q);
-        if ((M || P) && (M && M.name, P && P.name), M && P) {
-          o(M === P);
-          const T = f(oe), G = f(Q), he = M.compose(T, G);
-          y(we, M, he), N.add(Q);
-        } else M ? y(we, M, f(oe)) : P && (y(we, P, f(Q)), N.add(Q));
-        const U = typeof A == "object" && A != null;
-        let J = !1, X = 0, ee = 0, fe = 0, ce = 0, ae = 0;
-        const Oe = r.advancer(K, (T, G) => s(G) ? ce - T - 1 : T - ce, (T, G) => {
-          s(G) && ce++;
-        }), H = r.advancer(S, (T, G) => _(G) ? X - T - 1 : T - X, (T, G) => {
-          _(G) && X++;
+        } 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 (r.eachChildOf(re, te, (T, G, he) => {
-          let be, Re, qe = T, Me = T, Je = T;
-          if (typeof T == "number") {
-            let _e = T + fe;
-            Re = Oe(_e), Me = _e + ce;
-            let ue = T + ee;
-            be = H(ue), s(l(Re)) && (be = null), qe = ue + X, Je = T + ae, o(qe >= 0, "p1PickKey is negative"), o(Me >= 0, "p2DropKey is negative");
-            const Se = s(l(G)), xe = _(l(he));
-            (Se || xe && !Ne) && ae--, Se && ee--, xe && fe--;
-          } else be = H(T), Re = Oe(T);
-          ye.descend(qe), we.descend(Me);
-          const ze = U && !s(l(G)) ? A[Je] : void 0, ke = g(be, G, he, Re, ze, Ne, we, ye);
-          var je, j, ie;
-          U && !Ne ? ze !== ke && (J || (A = Array.isArray(A) ? A.slice() : Object.assign({}, A), J = !0), je = A, ie = ke, typeof (j = Je) == "number" ? (o(Array.isArray(je)), o(j < je.length)) : (o(!Array.isArray(je)), o(je[j] !== void 0)), ie === void 0 ? typeof j == "number" ? je.splice(j, 1) : delete je[j] : je[j] = ie) : o(ke === void 0), we.ascend(), ye.ascend();
-        }), H.end(), Oe.end(), W != null) W.i = A;
-        else if (!$e && !Ae && Ie == null) return A;
-      }(D, D.clone(), w, w.clone(), void 0, !1, I, B), I.reset(), I.mergeTree(B.get()), I.reset(), I.get(), R.map((g) => g.get()), $.map((g) => g.get()), D.traverse(I, (g, S) => {
-        const re = g.p;
-        if (re != null) {
-          const te = b[re];
-          te != null && S.write("p", te);
-          const K = R[re];
-          K && K.get(), K && S.mergeTree(K.get());
-        } else g.r !== void 0 && S.write("r", g.r);
-      }), I.reset(), I.get(), w.traverse(I, (g, S) => {
-        const re = g.d;
-        if (re != null) {
-          const K = C[re];
-          K != null && S.write("d", K);
-          const se = $[re];
-          se && S.mergeTree(se.get());
-        } else g.i !== void 0 && S.write("i", g.i);
-        const te = me(g);
-        te && !N.has(g) && y(S, te, f(g));
-      }), I.get();
+        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();
     }
-    function le(i) {
-      if (i == null) return null;
-      const c = new r.ReadCursor(i), O = new r.WriteCursor();
-      let D;
-      const w = [], I = [];
-      return function R($, p, m) {
-        const b = $.getComponent();
-        let C, N = !1;
-        if (b) {
-          b.p != null && (p.write("d", b.p), w[b.p] = $.clone()), b.r !== void 0 && p.write("i", b.r), b.d != null && (p.write("p", b.d), m = void 0), b.i !== void 0 && (m = C = b.i);
-          const g = me(b);
-          g && (m === void 0 ? (D || (D = /* @__PURE__ */ new Set()), D.add(b)) : (f(b), m = g.apply(m, f(b)), N = !0));
+    __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 B = 0;
-        for (const g of $) {
-          p.descend(g);
-          const S = typeof g == "number" ? g - B : g, re = Y(m, S);
-          s($.getComponent()) && B++;
-          const te = R($, p, re);
-          if (m !== void 0 && te !== void 0) {
-            if (N || (N = !0, m = x(m)), !k(m, S)) throw Error("Cannot modify child - invalid operation");
-            m[S] = 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 (C === void 0) return N ? m : void 0;
-        p.write("r", m);
-      }(c, O, void 0), D && (O.reset(), function R($, p, m) {
-        const b = p.getComponent();
-        if (b) {
-          const g = b.d;
-          if (g != null && ($ = w[g], m = I[g] = r.writeCursor()), D.has(b)) {
-            const S = me(b);
-            if (!S.invert) throw Error(`Cannot invert subtype ${S.name}`);
-            y(m, S, S.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 C = 0, N = 0;
-        const B = r.advancer($, (g, S) => _(S) ? C - g - 1 : g - C, (g, S) => {
-          _(S) && C++;
+        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 S = g - N, re = B(S), te = S + C;
-          m.descend(te), R(re, p, m), s(p.getComponent()) && N++, m.ascend();
-        } else m.descend(g), R(B(g), p, m), m.ascend();
-        B.end();
-      }(c.clone(), c, O), I.length && (O.reset(), c.traverse(O, (R, $) => {
-        const p = R.p;
-        if (p != null) {
-          const m = I[p];
-          m && m.get(), m && $.mergeTree(m.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());
         }
-      }))), O.get();
+      }))), w.get();
     }
-    const ge = (i, c) => i.some((O) => typeof O == "object" && (Array.isArray(O) ? ge(O, c) : c(O)));
-    function De(i, c) {
-      if (i == null || !ge(i, (p) => {
-        var m;
-        return p.r !== void 0 || ((m = me(p)) === null || m === void 0 ? void 0 : m.makeInvertible) != null;
-      })) return i;
-      const O = new r.ReadCursor(i), D = new r.WriteCursor();
-      let w = !1;
-      const I = [], R = [], $ = (p, m, b) => {
-        const C = p.getComponent();
-        let N = !1;
-        if (C) {
-          C.d != null && m.write("d", C.d), C.i !== void 0 && m.write("i", C.i);
-          const g = C.p;
-          if (g != null && (I[g] = p.clone(), o(b !== void 0, "Operation picks up at an invalid key"), R[g] = b, m.write("p", C.p)), C.r !== void 0 && b === void 0) throw Error("Invalid doc / op in makeInvertible: removed item missing from doc");
-          const S = me(C);
-          S && (S.makeInvertible ? w = !0 : y(m, S, f(C), !0));
+    __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 B = 0;
-        for (const g of p) {
-          m.descend(g);
-          const S = typeof g == "number" ? g - B : g, re = Y(b, S), te = $(p, m, re);
-          re !== te && (N || (N = !0, b = x(b)), te === void 0 ? (b = d(b, S), typeof g == "number" && B++) : b[S] = te), m.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 C && (C.r !== void 0 ? (m.write("r", t.default(b)), b = void 0) : C.p != null && (b = void 0)), b;
-      };
-      return $(O, D, c), D.get(), w && (D.reset(), function p(m, b, C, N, B) {
-        const g = b.getComponent();
-        if (g) {
-          g.i !== void 0 ? (N = g.i, B = !0) : g.d != null && (N = R[g.d], m = I[g.d], B = !1, g.d);
-          let K = me(g);
-          if (K && K.makeInvertible) {
-            const se = f(g);
-            y(C, K, K.makeInvertible(se, N), !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 S = 0, re = 0;
-        const te = r.advancer(m, (K, se) => _(se) ? S - K - 1 : K - S, (K, se) => {
-          _(se) && S++;
+        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, $e = te(se), we = se + S, ye = Y(N, B ? se : we);
-          C.descend(K), p($e, b, C, ye, B), s(b.getComponent()) && re++, C.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 = Y(N, K);
-          C.descend(K), p(te(K), b, C, se, B), C.ascend();
+          const child = maybeGetChild(subDoc, key);
+          w2.descend(key), traverseDrop(ap(key), rDrop, w2, child, isLiteral), w2.ascend();
         }
-        te.end();
-      }(O.clone(), O, D, c, !1)), D.get();
+        ap.end();
+      }, "traverseDrop"))(r.clone(), r, w, doc, !1)), w.get();
     }
-    function kt(i, c) {
-      return le(De(i, c));
+    __name(makeInvertible, "makeInvertible");
+    function invertWithDoc(op, doc) {
+      return invert(makeInvertible(op, doc));
     }
-    const it = (i) => {
-      if (i == null) return null;
-      const c = i.slice();
-      for (let O = 0; O < i.length; O++) {
-        const D = c[O];
-        Array.isArray(D) && (c[O] = it(D));
+    __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 c;
-    };
-    function st(i, c, O) {
-      o(O === "left" || O === "right", "Direction must be left or right");
-      const D = O === "left" ? 0 : 1;
-      if (c == 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: i
+        result: op1
       };
-      z(i), z(c);
-      let w = null;
-      const I = [], R = [], $ = [], p = [], m = [], b = [], C = [], N = [], B = [], g = [], S = [], re = [], te = [], K = [], se = [];
-      let $e = 0;
-      const we = r.readCursor(i), ye = r.readCursor(c), oe = r.writeCursor();
-      if (function Q(A, W = null, M) {
-        const P = l(W);
-        P && (P.r !== void 0 ? M = W.clone() : P.p != null && (M = null, b[P.p] = A.clone()));
-        const U = A.getComponent();
-        let J;
-        U && (J = U.p) != null && (m[J] = W ? W.clone() : null, $[J] = A.clone(), M && (g[J] = !0, B[J] = M), P && P.p != null && (K[J] = P.p));
-        const X = r.advancer(W);
-        for (const ee of A) Q(A, X(ee), M);
-        X.end();
-      }(ye, we, null), function Q(A, W, M, P, U) {
-        const J = M.getComponent();
-        let X, ee = !1;
-        J && ((X = J.d) != null ? (p[X] = M.clone(), P != null && (se[P] == null && (se[P] = []), se[P].push(X)), g[X], A = m[X] || null, W = $[X] || null, g[X] ? (U && (S[X] = !0), U = B[X] || null) : !U || D !== 1 && K[X] != null || w == null && (w = {
-          type: u.ConflictType.RM_UNEXPECTED_CONTENT,
-          op1: a.removeOp(U.getPath()),
-          op2: a.moveOp(W.getPath(), M.getPath())
-        }), ee = !0) : J.i !== void 0 && (A = W = null, ee = !0, U && w == null && (w = {
-          type: u.ConflictType.RM_UNEXPECTED_CONTENT,
-          op1: a.removeOp(U.getPath()),
-          op2: a.insertOp(M.getPath(), J.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)), cancelledOp2[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 = l(A);
-        fe && (fe.r !== void 0 ? U = A.clone() : fe.p != null && (fe.p, P = fe.p, U = null));
-        const ce = me(J);
-        ce && U && w == null && (w = {
-          type: u.ConflictType.RM_UNEXPECTED_CONTENT,
-          op1: a.removeOp(U.getPath()),
-          op2: a.editOp(M.getPath(), ce, f(J), !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 ae = 0, Oe = 0;
-        const H = r.advancer(W, (G, he) => _(he) ? ae - G - 1 : G - ae, (G, he) => {
-          _(he) && ae++;
-        }), T = r.advancer(A);
-        for (const G of M) if (typeof G == "number") {
-          const he = G - Oe, be = H(he);
-          Oe += +Q(T(he + ae), be, M, P, U);
+        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 = H(G);
-          Q(T(G), he, M, P, U);
+          const _p2Pick = ap2(key);
+          scanOp2Drop(ap1(key), _p2Pick, r2Drop, pickSlot1, removed1);
         }
-        return H.end(), T.end(), ee;
-      }(we, ye, ye.clone(), null, null), p.map((Q) => Q && Q.get()), w) 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: w
+        conflict
       };
-      S.map((Q) => !!Q);
-      const Pe = [];
-      let Ae = null;
-      (function Q(A, W, M, P, U) {
-        let J = !1;
-        const X = l(W);
-        if (_(X)) {
-          const H = X.p;
-          H != null ? (M = p[H], P = re[H] = r.writeCursor(), J = !0, U = null) : (M = null, U = W.clone());
-        } else s(l(M)) && (M = null);
-        const ee = A.getComponent();
-        if (ee) {
-          const H = ee.p;
-          H != null ? (U && (N[H] = U), Pe[H] = U || D === 1 && J ? null : P.getComponent(), I[H] = A.clone(), M && (C[H] = M.clone())) : ee.r !== void 0 && (U || P.write("r", !0), (U || J) && (Ae == null && (Ae = /* @__PURE__ */ new Set()), Ae.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, ce = 0;
-        const ae = r.advancer(W, void 0, (H, T) => {
-          _(T) && fe++;
-        }), Oe = r.advancer(M, (H, T) => s(T) ? ~(H - ce) : H - ce, (H, T) => {
-          s(T) && ce++;
+        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 (A) for (const H of A) if (typeof H == "string") {
-          const T = ae(H), G = Oe(H);
-          P.descend(H), Q(A, T, G, P, U), P.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 T = ae(H), G = H - fe, he = _(l(T)) ? null : Oe(G), be = G + ce;
-          o(be >= 0), P.descend(be), Q(A, T, he, P, U), P.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();
         }
-        ae.end(), Oe.end();
-      })(we, ye, ye.clone(), oe, null), oe.reset();
-      let Le = [];
-      if (function Q(A, W, M, P, U, J) {
-        o(W);
-        const X = W.getComponent();
-        let ee = l(P), fe = !1;
-        const ce = (j, ie, _e) => j ? a.moveOp(j.getPath(), ie.getPath()) : a.insertOp(ie.getPath(), _e.i);
-        if (s(X)) {
-          const j = X.d;
-          j != null && (R[j] = W.clone());
-          const ie = j != null ? Pe[j] : null;
-          let _e = !1;
-          if (X.i !== void 0 || j != null && ie) {
-            let ue;
-            ee && (ee.i !== void 0 || (ue = ee.d) != null && !g[ue]) && (_e = ue != null ? j != null && j === K[ue] : n.default(ee.i, X.i), _e || ue != null && D !== 1 && K[ue] != null || w == null && (w = {
-              type: u.ConflictType.DROP_COLLISION,
-              op1: ce(j != null ? I[j] : null, W, X),
-              op2: ce(ue != null ? $[ue] : null, P, ee)
-            })), _e || (J ? w == null && (w = {
-              type: u.ConflictType.RM_UNEXPECTED_CONTENT,
-              op1: ce(j != null ? I[j] : null, W, X),
-              op2: a.removeOp(J.getPath())
-            }) : (j != null ? (Le[$e] = j, U.write("d", ie.p = $e++)) : U.write("i", t.default(X.i)), fe = !0));
-          } else if (j != null && !ie) {
-            const ue = N[j];
-            ue && (J = ue.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());
           }
-          j != null ? (A = I[j], M = b[j], P = C[j]) : X.i !== void 0 && (A = M = null, _e || (P = null));
-        } else _(l(A)) && (A = M = P = null);
-        const ae = l(A), Oe = l(M);
-        if (_(Oe)) {
-          const j = Oe.p;
-          Oe.r !== void 0 && (!ae || ae.r === void 0) || g[j] ? (P = null, J = M.clone()) : j != null && (P = p[j], D !== 1 && K[j] != null || ((U = te[j]) || (U = te[j] = r.writeCursor()), U.reset(), J = null));
-        } else !s(X) && s(ee) && (P = null);
-        ee = P != null ? P.getComponent() : null;
-        const H = me(X);
-        if (H) {
-          const j = f(X);
-          if (J) w == null && (w = {
-            type: u.ConflictType.RM_UNEXPECTED_CONTENT,
-            op1: a.editOp(W.getPath(), H, j, !0),
-            op2: a.removeOp(J.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 = me(ee);
-            let _e;
-            if (ie) {
-              if (H !== ie) throw Error("Transforming incompatible types");
-              const ue = f(ee);
-              _e = H.transform(j, ue, O);
-            } else _e = t.default(j);
-            y(U, H, _e);
+            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 T = 0, G = 0, he = 0, be = 0, Re = 0, qe = 0, Me = A != null && A.descendFirst(), Je = Me;
-        const ze = r.advancer(M, void 0, (j, ie) => {
-          _(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 ke = P != null && P.descendFirst(), je = ke;
-        for (const j of W) if (typeof j == "number") {
-          let ie;
-          const _e = s(W.getComponent()), ue = j - G;
+        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 (; Me && typeof (Be = A.getKey()) == "number"; ) {
-              Be += T;
-              const Ue = A.getComponent(), Xe = _(Ue);
-              if (Be > ue || Be === ue && (!Xe || D === 0 && _e)) break;
-              if (Xe) {
-                T--;
-                const Ke = Ue.p;
-                K.includes(Ke), Ue.d, l(te[Ue.d]), _(l(te[Ue.d])), (Ue.r === void 0 || Ae && Ae.has(Ue)) && (Ke == null || !Pe[Ke] || D !== 1 && K.includes(Ke)) || Re--;
+            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--;
               }
-              Me = A.nextSibling();
+              p1pValid = p1Pick.nextSibling();
             }
-            ie = Me && Be === ue ? A : null;
+            _p1Pick = p1pValid && p1k === k1Mid ? p1Pick : null;
           }
-          const Se = ue - T;
-          let xe = ze(Se);
-          const ot = Se - he;
-          let Ze = null;
+          const raw = k1Mid - p1PickOff;
+          let _p2Pick = ap2p(raw);
+          const k2Mid = raw - p2PickOff;
+          let _p2Drop = null;
           {
-            let Be, Ue;
-            for (; ke && typeof (Be = P.getKey()) == "number"; ) {
-              Ue = Be - be;
-              const Xe = P.getComponent(), Ke = s(Xe);
-              if (Ue > ot) break;
-              if (Ue === ot) {
-                if (!Ke) {
-                  Ze = P;
+            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 && _e) {
-                    Ze = P;
+                  if (side === 0 && hd1) {
+                    _p2Drop = p2Drop;
                     break;
                   }
-                  const We = xe && _(xe.getComponent());
-                  if (D === 0 && We) break;
+                  const hp2 = _p2Pick && hasPick(_p2Pick.getComponent());
+                  if (side === 0 && hp2) break;
                 }
               }
-              if (Ke) {
-                const We = Xe.d;
-                g[We], K[We], Xe.i === void 0 && (g[We] || K[We] != null && D !== 1) ? (g[We] || K[We] != null && D === 0) && (be++, qe--) : be++;
+              if (hd2) {
+                const slot2 = c.d;
+                cancelledOp2[slot2], op1PickAtOp2Pick[slot2], c.i === void 0 && (cancelledOp2[slot2] || op1PickAtOp2Pick[slot2] != null && side !== 1) ? (cancelledOp2[slot2] || op1PickAtOp2Pick[slot2] != null && side === 0) && (p2DropOff++, outDropOff--) : p2DropOff++;
               }
-              ke = P.nextSibling();
+              p2dValid = p2Drop.nextSibling();
             }
           }
-          const _t = ot + be + Re + qe;
-          o(_t >= 0, "trying to descend to a negative index"), U.descend(_t), _e && (ie = xe = Ze = null, G++), Q(ie, W, xe, Ze, U, J) && qe++, U.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 (; Me && (ie = A.getKey(), typeof ie != "string" || !(ie > j || ie === j)); ) Me = A.nextSibling();
-          const _e = Me && ie === j ? A : null, ue = ze(j);
-          let Se;
-          for (; ke && (Se = P.getKey(), typeof Se != "string" || !(Se > j || Se === j)); ) ke = P.nextSibling();
-          const xe = ke && Se === j ? P : null;
-          U.descend(j), Q(_e, W, ue, xe, U, J), U.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(), Je && A.ascend(), je && P.ascend(), fe;
-      }(we, we.clone(), ye, ye.clone(), oe, null), w) 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: w
+        conflict
       };
-      oe.reset();
-      const Te = (Q, A, W) => Q.traverse(A, (M, P) => {
-        M.d != null && W(M.d, Q, P);
-      });
-      (g.length || re.length) && (Te(ye, oe, (Q, A, W) => {
-        g[Q] && !S[Q] && W.write("r", !0), re[Q] && W.mergeTree(re[Q].get());
-      }), oe.reset());
-      const Ie = [], Ne = [];
-      if ((te.length || g.length) && !w) {
-        const Q = r.readCursor(it(oe.get()));
-        if (Te(Q, null, (A, W) => {
-          Ie[A] = W.clone();
-        }), te.forEach((A) => {
-          A && Te(r.readCursor(A.get()), null, (W, M) => {
-            Ie[W] = M.clone();
+      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 A(W, M, P, U, J, X) {
-          const ee = l(M);
-          if (ee && _(ee)) if (ee.p != null) {
-            const T = ee.p;
-            Ie[T].getPath(), P = Ie[T], U = Ne[T] = r.writeCursor();
-          } else ee.r !== void 0 && (P = null);
-          else s(l(P)) && (P = null);
-          const fe = W.getComponent();
-          if (fe) {
-            let T;
-            if ((T = fe.d) != null) {
-              const G = te[T];
-              G && (G.get(), U.mergeTree(G.get()), P = r.readCursor(G.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 ce = 0, ae = 0;
-          const Oe = r.advancer(M, void 0, (T, G) => {
-            _(G) && ce--;
-          }), H = r.advancer(P, (T, G) => s(G) ? -(T - ae) - 1 : T - ae, (T, G) => {
-            s(G) && ae++;
+          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 T of W) if (typeof T == "number") {
-            const G = Oe(T), he = T + ce, be = H(he), Re = he + ae;
-            U.descend(Re), A(W, G, be, U), U.ascend();
-          } else U.descend(T), A(W, Oe(T), H(T), U), U.ascend();
-          Oe.end(), H.end();
-        }(ye, Q, Q.clone(), oe), oe.reset(), w) 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: w
+          conflict
         };
-        if (oe.get(), Ne.length) {
-          const A = Ne.map((M) => M ? M.get() : null), W = r.readCursor(it(oe.get()));
-          if (Te(W, oe, (M, P, U) => {
-            const J = A[M];
-            J && (U.mergeTree(J), A[M] = null);
-          }), A.find((M) => M)) {
-            const M = r.writeCursor(), P = r.writeCursor();
-            let U = 0, J = 0;
-            A.forEach((X) => {
-              X != null && Te(r.readCursor(X), null, (ee) => {
-                const fe = Le[ee];
-                M.writeMove(I[fe].getPath(), R[fe].getPath(), U++);
-                const ce = se[fe];
-                ce && ce.forEach((ae) => {
-                  g[ae] || D !== 1 && K[ae] != null || P.writeMove($[ae].getPath(), p[ae].getPath(), J++);
+        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++);
                 });
               });
-            }), w = {
-              type: u.ConflictType.BLACKHOLE,
-              op1: M.get(),
-              op2: P.get()
+            }), conflict = {
+              type: types_js_1.ConflictType.BLACKHOLE,
+              op1: w1.get(),
+              op2: w2.get()
             };
           }
         }
       }
-      return w ? {
+      return conflict ? {
         ok: !1,
-        conflict: w
+        conflict
       } : {
         ok: !0,
-        result: oe.get()
+        result: w.get()
       };
     }
-    const gt = (i) => {
-      const c = new Error("Transform detected write conflict");
-      throw c.conflict = i, c.type = c.name = "writeConflict", c;
-    };
-    function jt(i, c, O) {
-      const D = st(i, c, O);
-      if (D.ok) return D.result;
-      gt(D.conflict);
+    __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);
     }
-    const He = (i) => {
-      const c = r.writeCursor();
-      return r.readCursor(i).traverse(c, (O, D) => {
-        (s(O) || me(O)) && D.write("r", !0);
-      }), c.get();
-    }, $t = (i, c) => {
-      const { type: O, op1: D, op2: w } = i;
-      switch (O) {
-        case u.ConflictType.DROP_COLLISION:
-          return c === "left" ? [null, He(w)] : [He(D), null];
-        case u.ConflictType.RM_UNEXPECTED_CONTENT:
-          let I = !1;
-          return r.readCursor(D).traverse(null, (R) => {
-            R.r !== void 0 && (I = !0);
-          }), I ? [null, He(w)] : [He(D), null];
-        case u.ConflictType.BLACKHOLE:
-          return [He(D), He(w)];
+    __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: " + O);
+          throw Error("Unrecognised conflict: " + type2);
       }
-    };
-    function yt(i, c, O, D) {
-      let w = null;
+    }, "resolveConflict");
+    function transformWithConflictsPred(allowConflict, op1, op2, side) {
+      let r2Aggregate = null;
       for (; ; ) {
-        const I = st(c, O, D);
-        if (I.ok) return ne(w, I.result);
+        const res = tryTransform(op1, op2, side);
+        if (res.ok) return compose(r2Aggregate, res.result);
         {
-          const { conflict: R } = I;
-          i(R) || gt(R);
-          const [$, p] = $t(R, D);
-          c = ne(q(c), $), O = ne(q(O), p), w = ne(w, 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);
         }
       }
     }
-  }(et)), et;
+    __name(transformWithConflictsPred, "transformWithConflictsPred");
+  }(json1_release)), json1_release;
 }
-var Pt;
-function sn() {
-  return Pt || (Pt = 1, function(a) {
-    var e = Ye.__createBinding || (Object.create ? function(u, o, l, E) {
-      E === void 0 && (E = l), Object.defineProperty(u, E, { enumerable: !0, get: function() {
-        return o[l];
-      } });
-    } : function(u, o, l, E) {
-      E === void 0 && (E = l), u[E] = o[l];
-    }), n = Ye.__exportStar || function(u, o) {
-      for (var l in u) l !== "default" && !o.hasOwnProperty(l) && e(o, u, l);
+__name(requireJson1_release, "requireJson1_release");
+var hasRequiredDist;
+function requireDist() {
+  return hasRequiredDist || (hasRequiredDist = 1, function(exports) {
+    var __createBinding = dist$1.__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 = dist$1.__exportStar || function(m, exports2) {
+      for (var p in m) p !== "default" && !exports2.hasOwnProperty(p) && __createBinding(exports2, m, p);
     };
-    Object.defineProperty(a, "__esModule", { value: !0 }), n(rn(), a);
-    var t = Mt();
-    Object.defineProperty(a, "ReadCursor", { enumerable: !0, get: function() {
-      return t.ReadCursor;
-    } }), Object.defineProperty(a, "WriteCursor", { enumerable: !0, get: function() {
-      return t.WriteCursor;
-    } });
-    var r = St();
-    Object.defineProperty(a, "ConflictType", { enumerable: !0, get: function() {
-      return r.ConflictType;
-    } });
-  }(Ye)), Ye;
+    Object.defineProperty(exports, "__esModule", { value: !0 }), __exportStar(requireJson1_release(), exports);
+    var cursor_js_1 = requireCursor();
+    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 = requireTypes();
+    Object.defineProperty(exports, "ConflictType", { enumerable: !0, get: /* @__PURE__ */ __name(function() {
+      return types_1.ConflictType;
+    }, "get") });
+  }(dist$1)), dist$1;
 }
-var V = sn();
-class on {
+__name(requireDist, "requireDist");
+var distExports = requireDist();
+const _UnitDrawingService = class _UnitDrawingService {
   constructor() {
-    F(this, "drawingManagerData", {});
-    F(this, "_oldDrawingManagerData", {});
-    F(this, "_focusDrawings", []);
-    F(this, "_remove$", new ve());
-    F(this, "remove$", this._remove$.asObservable());
-    F(this, "_add$", new ve());
-    F(this, "add$", this._add$.asObservable());
-    F(this, "_update$", new ve());
-    F(this, "update$", this._update$.asObservable());
-    F(this, "_order$", new ve());
-    F(this, "order$", this._order$.asObservable());
-    F(this, "_group$", new ve());
-    F(this, "group$", this._group$.asObservable());
-    F(this, "_ungroup$", new ve());
-    F(this, "ungroup$", this._ungroup$.asObservable());
-    F(this, "_refreshTransform$", new ve());
-    F(this, "refreshTransform$", this._refreshTransform$.asObservable());
-    F(this, "_visible$", new ve());
-    F(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();
-    F(this, "_focus$", new ve());
-    F(this, "focus$", this._focus$.asObservable());
-    F(this, "_featurePluginUpdate$", new ve());
-    F(this, "featurePluginUpdate$", this._featurePluginUpdate$.asObservable());
-    F(this, "_featurePluginAdd$", new ve());
-    F(this, "featurePluginAdd$", this._featurePluginAdd$.asObservable());
-    F(this, "_featurePluginRemove$", new ve());
-    F(this, "featurePluginRemove$", this._featurePluginRemove$.asObservable());
-    F(this, "_featurePluginOrderUpdate$", new ve());
-    F(this, "featurePluginOrderUpdate$", this._featurePluginOrderUpdate$.asObservable());
-    F(this, "_featurePluginGroupUpdate$", new ve());
-    F(this, "featurePluginGroupUpdate$", this._featurePluginGroupUpdate$.asObservable());
-    F(this, "_featurePluginUngroupUpdate$", new ve());
-    F(this, "featurePluginUngroupUpdate$", this._featurePluginUngroupUpdate$.asObservable());
-    F(this, "_visible", !0);
-    F(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((n) => {
-      const t = this._getCurrentBySearch(n);
-      t != null && (t.transform = n.transform, t.transforms = n.transforms, t.isMultiTransform = n.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 n = this.drawingManagerData[e];
-    if (n == null)
+  removeDrawingDataForUnit(unitId) {
+    const subUnits = this.drawingManagerData[unitId];
+    if (subUnits == null)
       return;
-    delete this.drawingManagerData[e];
-    const t = [];
-    Object.keys(n).forEach((r) => {
-      const u = n[r];
-      (u == null ? void 0 : u.data) != null && Object.keys(u.data).forEach((o) => {
-        t.push({ unitId: e, subUnitId: r, drawingId: o });
+    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 });
       });
-    }), t.length > 0 && this.removeNotification(t);
-  }
-  registerDrawingData(e, n) {
-    this.drawingManagerData[e] = n;
-  }
-  initializeNotification(e) {
-    const n = [], t = this.drawingManagerData[e];
-    t != null && (Object.keys(t).forEach((r) => {
-      this._establishDrawingMap(e, r);
-      const u = t[r];
-      Object.keys(u.data).forEach((o) => {
-        const l = u.data[o];
-        l.unitId = e, l.subUnitId = r, n.push(l);
+    }), 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);
       });
-    }), n.length > 0 && this.addNotification(n));
+    }), drawings.length > 0 && this.addNotification(drawings));
   }
-  getDrawingData(e, n) {
-    return this._getDrawingData(e, n);
+  getDrawingData(unitId, subUnitId) {
+    return this._getDrawingData(unitId, subUnitId);
   }
   // Use in doc only.
-  setDrawingData(e, n, t) {
-    this.drawingManagerData[e][n].data = t;
-  }
-  getBatchAddOp(e) {
-    const n = [], t = [], r = [];
-    e.forEach((x) => {
-      const { op: _, invertOp: s } = this._addByParam(x);
-      n.push({ unitId: x.unitId, subUnitId: x.subUnitId, drawingId: x.drawingId }), t.push(_), r.push(s);
+  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 u = t.reduce(V.type.compose, null), o = r.reduce(V.type.compose, null), { unitId: l, subUnitId: E } = e[0];
-    return { undo: o, redo: u, unitId: l, subUnitId: E, objects: n };
-  }
-  getBatchRemoveOp(e) {
-    const n = [], t = [];
-    e.forEach((E) => {
-      const { op: x, invertOp: _ } = this._removeByParam(E);
-      n.unshift(x), t.push(_);
+    const op = ops.reduce(distExports.type.compose, null), invertOp = invertOps.reduce(distExports.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.unshift(op2), invertOps.push(invertOp2);
     });
-    const r = n.reduce(V.type.compose, null), u = t.reduce(V.type.compose, null), { unitId: o, subUnitId: l } = e[0];
-    return { undo: u, redo: r, unitId: o, subUnitId: l, objects: e };
-  }
-  getBatchUpdateOp(e) {
-    const n = [], t = [], r = [];
-    e.forEach((x) => {
-      const { op: _, invertOp: s } = this._updateByParam(x);
-      n.push({ unitId: x.unitId, subUnitId: x.subUnitId, drawingId: x.drawingId }), t.push(_), r.push(s);
+    const op = ops.reduce(distExports.type.compose, null), invertOp = invertOps.reduce(distExports.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 u = t.reduce(V.type.compose, null), o = r.reduce(V.type.compose, null), { unitId: l, subUnitId: E } = e[0];
-    return { undo: o, redo: u, unitId: l, subUnitId: E, objects: n };
+    const op = ops.reduce(distExports.type.compose, null), invertOp = invertOps.reduce(distExports.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 n = [], { unitId: t, subUnitId: r } = e[0].parent;
-    e.forEach((l) => {
-      n.push(this._getGroupDrawingOp(l));
+  getGroupDrawingOp(groupParams) {
+    const ops = [], { unitId, subUnitId } = groupParams[0].parent;
+    groupParams.forEach((groupParam) => {
+      ops.push(this._getGroupDrawingOp(groupParam));
     });
-    const u = n.reduce(V.type.compose, null);
-    return { undo: V.type.invertWithDoc(u, this.drawingManagerData), redo: u, unitId: t, subUnitId: r, objects: e };
+    const op = ops.reduce(distExports.type.compose, null);
+    return { undo: distExports.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: groupParams };
   }
-  getUngroupDrawingOp(e) {
-    const n = [], { unitId: t, subUnitId: r } = e[0].parent;
-    e.forEach((l) => {
-      n.push(this._getUngroupDrawingOp(l));
+  getUngroupDrawingOp(groupParams) {
+    const ops = [], { unitId, subUnitId } = groupParams[0].parent;
+    groupParams.forEach((groupParam) => {
+      ops.push(this._getUngroupDrawingOp(groupParam));
     });
-    const u = n.reduce(V.type.compose, null);
-    return { undo: V.type.invertWithDoc(u, this.drawingManagerData), redo: u, unitId: t, subUnitId: r, objects: e };
+    const op = ops.reduce(distExports.type.compose, null);
+    return { undo: distExports.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: groupParams };
   }
-  getDrawingsByGroup(e) {
-    const { unitId: n, subUnitId: t, drawingId: r } = e;
-    if (this.getDrawingByParam({ unitId: n, subUnitId: t, drawingId: r }) == null)
+  getDrawingsByGroup(groupParam) {
+    const { unitId, subUnitId, drawingId } = groupParam;
+    if (this.getDrawingByParam({ unitId, subUnitId, drawingId }) == null)
       return [];
-    const o = this._getDrawingData(n, t), l = [];
-    return Object.keys(o).forEach((E) => {
-      const x = o[E];
-      x.groupId === r && l.push(x);
-    }), l;
-  }
-  _getGroupDrawingOp(e) {
-    const { parent: n, children: t } = e, { unitId: r, subUnitId: u, drawingId: o } = n, l = [];
-    l.push(
-      V.insertOp([r, u, "data", o], n)
+    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(
+      distExports.insertOp([groupUnitId, groupSubUnitId, "data", groupDrawingId], parent)
     );
-    let E = Number.NEGATIVE_INFINITY;
-    return t.forEach((x) => {
-      const { unitId: _, subUnitId: s, drawingId: d } = x, h = this._hasDrawingOrder({ unitId: _, subUnitId: s, drawingId: d });
-      E = Math.max(E, h), l.push(
-        ...this._getUpdateParamCompareOp(x, this.getDrawingByParam({ unitId: _, subUnitId: s, drawingId: d }))
+    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(r, u).length), l.push(
-      V.insertOp([r, u, "order", E], o)
-    ), l.reduce(V.type.compose, null);
-  }
-  _getUngroupDrawingOp(e) {
-    const { parent: n, children: t } = e, { unitId: r, subUnitId: u, drawingId: o } = n, l = [];
-    return t.forEach((E) => {
-      const { unitId: x, subUnitId: _, drawingId: s } = E;
-      l.push(
-        ...this._getUpdateParamCompareOp(E, this.getDrawingByParam({ unitId: x, subUnitId: _, drawingId: s }))
+    }), maxChildIndex === Number.NEGATIVE_INFINITY && (maxChildIndex = this._getDrawingOrder(groupUnitId, groupSubUnitId).length), ops.push(
+      distExports.insertOp([groupUnitId, groupSubUnitId, "order", maxChildIndex], groupDrawingId)
+    ), ops.reduce(distExports.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 }))
       );
-    }), l.push(
-      V.removeOp([r, u, "data", o], !0)
-    ), l.push(
-      V.removeOp([r, u, "order", this._getDrawingOrder(r, u).indexOf(o)], !0)
-    ), l.reduce(V.type.compose, null);
+    }), ops.push(
+      distExports.removeOp([groupUnitId, groupSubUnitId, "data", groupDrawingId], !0)
+    ), ops.push(
+      distExports.removeOp([groupUnitId, groupSubUnitId, "order", this._getDrawingOrder(groupUnitId, groupSubUnitId).indexOf(groupDrawingId)], !0)
+    ), ops.reduce(distExports.type.compose, null);
   }
-  applyJson1(e, n, t) {
-    this._establishDrawingMap(e, n), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = V.type.apply(this.drawingManagerData, t);
+  applyJson1(unitId, subUnitId, jsonOp) {
+    this._establishDrawingMap(unitId, subUnitId), this._oldDrawingManagerData = { ...this.drawingManagerData }, this.drawingManagerData = distExports.type.apply(this.drawingManagerData, jsonOp);
   }
   // private _fillMissingFields(jsonOp: JSONOp) {
   //     if (jsonOp == null) {
@@ -1695,163 +1738,163 @@ class on {
   //         }
   //     }
   // }
-  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 [n, t, r] = e.split("#-#");
-    return this._getCurrentBySearch({ unitId: n, subUnitId: t, drawingId: r });
+  getDrawingOKey(oKey) {
+    const [unitId, subUnitId, drawingId] = oKey.split("#-#");
+    return this._getCurrentBySearch({ unitId, subUnitId, drawingId });
   }
-  focusDrawing(e) {
-    if (e == null || e.length === 0) {
+  focusDrawing(params) {
+    if (params == null || params.length === 0) {
       this._focusDrawings = [], this._focus$.next([]);
       return;
     }
-    const n = [];
-    e.forEach((t) => {
-      var E;
-      const { unitId: r, subUnitId: u, drawingId: o } = t, l = (E = this._getDrawingData(r, u)) == null ? void 0 : E[o];
-      l != null && n.push(l);
-    }), n.length > 0 && (this._focusDrawings = n, this._focus$.next(n));
+    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((n) => {
-      var l;
-      const { unitId: t, subUnitId: r, drawingId: u } = n, o = (l = this._getDrawingData(t, r)) == null ? void 0 : l[u];
-      o != null && e.push(o);
-    }), e;
+    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, n) {
-    return this._getDrawingOrder(e, n);
+  getDrawingOrder(unitId, subUnitId) {
+    return this._getDrawingOrder(unitId, subUnitId);
   }
   // Use in doc only.
-  setDrawingOrder(e, n, t) {
-    this.drawingManagerData[e][n].order = t;
+  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: n, subUnitId: t, drawingIds: r } = e, u = [], o = this.getDrawingOrder(n, t), l = [...r];
-    r.forEach((_) => {
-      const s = this._hasDrawingOrder({ unitId: n, subUnitId: t, drawingId: _ });
-      if (s === -1 || s === o.length - 1)
+  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 d = V.moveOp([n, t, "order", s], [n, t, "order", s + 1]);
-      u.push(d), l.includes(o[s + 1]) || l.push(o[s + 1]);
+      const op2 = distExports.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 = u.reduce(V.type.compose, null);
-    return { undo: V.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: n, subUnitId: t, objects: { ...e, drawingIds: l } };
-  }
-  getBackwardDrawingOp(e) {
-    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = [], o = this.getDrawingOrder(n, t), l = [...r];
-    r.forEach((_) => {
-      const s = this._hasDrawingOrder({ unitId: n, subUnitId: t, drawingId: _ });
-      if (s === -1 || s === 0)
+    const op = ops.reduce(distExports.type.compose, null);
+    return { undo: distExports.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 d = V.moveOp([n, t, "order", s], [n, t, "order", s - 1]);
-      u.push(d), l.includes(o[s - 1]) || l.push(o[s - 1]);
+      const op2 = distExports.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 = u.reduce(V.type.compose, null);
-    return { undo: V.type.invertWithDoc(E, this.drawingManagerData), redo: E, unitId: n, subUnitId: t, objects: { ...e, drawingIds: l } };
-  }
-  getFrontDrawingsOp(e) {
-    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = this._getOrderFromSearchParams(n, t, r), o = [...r], l = this.getDrawingOrder(n, t), E = [];
-    u.forEach((s) => {
-      const { drawingId: d } = s, h = this._getDrawingCount(n, t) - 1, k = V.moveOp([n, t, "order", this._getDrawingOrder(n, t).indexOf(d)], [n, t, "order", h]);
-      E.push(k), o.includes(l[h]) || o.push(l[h]);
+    const op = ops.reduce(distExports.type.compose, null);
+    return { undo: distExports.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 = distExports.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 x = E.reduce(V.type.compose, null);
-    return { undo: V.type.invertWithDoc(x, this.drawingManagerData), redo: x, unitId: n, subUnitId: t, objects: { ...e, drawingIds: o } };
-  }
-  getBackDrawingsOp(e) {
-    const { unitId: n, subUnitId: t, drawingIds: r } = e, u = this._getOrderFromSearchParams(n, t, r, !0), o = [...r], l = this.getDrawingOrder(n, t), E = [];
-    u.forEach((s) => {
-      const { drawingId: d } = s, h = V.moveOp([n, t, "order", this._getDrawingOrder(n, t).indexOf(d)], [n, t, "order", 0]);
-      E.push(h), o.includes(l[0]) || o.push(l[0]);
+    const op = ops.reduce(distExports.type.compose, null);
+    return { undo: distExports.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 = distExports.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 x = E.reduce(V.type.compose, null);
-    return { undo: V.type.invertWithDoc(x, this.drawingManagerData), redo: x, unitId: n, subUnitId: t, objects: { ...e, drawingIds: o } };
+    const op = ops.reduce(distExports.type.compose, null);
+    return { undo: distExports.type.invertWithDoc(op, this.drawingManagerData), redo: op, unitId, subUnitId, objects: { ...orderParams, drawingIds: newIds } };
   }
-  _getDrawingCount(e, n) {
-    return this.getDrawingOrder(e, n).length || 0;
+  _getDrawingCount(unitId, subUnitId) {
+    return this.getDrawingOrder(unitId, subUnitId).length || 0;
   }
-  _getOrderFromSearchParams(e, n, t, r = !1) {
-    return t.map((u) => {
-      const o = this._hasDrawingOrder({ unitId: e, subUnitId: n, drawingId: u });
-      return { drawingId: u, zIndex: o };
-    }).sort(r === !1 ? xt : Bt);
+  _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: n, subUnitId: t, drawingId: r } = e;
-    return this._establishDrawingMap(n, t), this._getDrawingOrder(n, t).indexOf(r);
+    const { unitId, subUnitId, drawingId } = searchParam;
+    return this._establishDrawingMap(unitId, subUnitId), this._getDrawingOrder(unitId, subUnitId).indexOf(drawingId);
   }
-  _getCurrentBySearch(e) {
-    var u, o, l;
-    if (e == null)
+  _getCurrentBySearch(searchParam) {
+    var _a2, _b, _c;
+    if (searchParam == null)
       return;
-    const { unitId: n, subUnitId: t, drawingId: r } = e;
-    return (l = (o = (u = this.drawingManagerData[n]) == null ? void 0 : u[t]) == null ? void 0 : o.data) == null ? void 0 : l[r];
+    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 u, o, l;
-    if (e == null)
+  _getOldBySearch(searchParam) {
+    var _a2, _b, _c;
+    if (searchParam == null)
       return;
-    const { unitId: n, subUnitId: t, drawingId: r } = e;
-    return (l = (o = (u = this._oldDrawingManagerData[n]) == null ? void 0 : u[t]) == null ? void 0 : o.data) == null ? void 0 : l[r];
+    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, n, t) {
-    var r;
-    return this.drawingManagerData[e] || (this.drawingManagerData[e] = {}), this.drawingManagerData[e][n] || (this.drawingManagerData[e][n] = {
+  _establishDrawingMap(unitId, subUnitId, drawingId) {
+    var _a2;
+    return this.drawingManagerData[unitId] || (this.drawingManagerData[unitId] = {}), this.drawingManagerData[unitId][subUnitId] || (this.drawingManagerData[unitId][subUnitId] = {
       data: {},
       order: []
-    }), t == null ? null : (r = this.drawingManagerData[e][n].data) == null ? void 0 : r[t];
+    }), drawingId == null ? null : (_a2 = this.drawingManagerData[unitId][subUnitId].data) == null ? void 0 : _a2[drawingId];
   }
-  _addByParam(e) {
-    const { unitId: n, subUnitId: t, drawingId: r } = e;
-    this._establishDrawingMap(n, t, r);
-    const u = V.insertOp([n, t, "data", r], e), o = V.insertOp([n, t, "order", this._getDrawingOrder(n, t).length], r), l = [u, o].reduce(V.type.compose, null), E = V.type.invertWithDoc(l, this.drawingManagerData);
-    return { op: l, invertOp: E };
+  _addByParam(insertParam) {
+    const { unitId, subUnitId, drawingId } = insertParam;
+    this._establishDrawingMap(unitId, subUnitId, drawingId);
+    const op1 = distExports.insertOp([unitId, subUnitId, "data", drawingId], insertParam), op2 = distExports.insertOp([unitId, subUnitId, "order", this._getDrawingOrder(unitId, subUnitId).length], drawingId), op = [op1, op2].reduce(distExports.type.compose, null), invertOp = distExports.type.invertWithDoc(op, this.drawingManagerData);
+    return { op, invertOp };
   }
-  _removeByParam(e) {
-    if (e == null)
+  _removeByParam(searchParam) {
+    if (searchParam == null)
       return { op: [], invertOp: [] };
-    const { unitId: n, subUnitId: t, drawingId: r } = e;
-    if (this._establishDrawingMap(n, t, r) == null)
+    const { unitId, subUnitId, drawingId } = searchParam;
+    if (this._establishDrawingMap(unitId, subUnitId, drawingId) == null)
       return { op: [], invertOp: [] };
-    const o = V.removeOp([n, t, "data", r], !0), l = V.removeOp([n, t, "order", this._getDrawingOrder(n, t).indexOf(r)], !0), E = [o, l].reduce(V.type.compose, null), x = V.type.invertWithDoc(E, this.drawingManagerData);
-    return { op: E, invertOp: x };
+    const op1 = distExports.removeOp([unitId, subUnitId, "data", drawingId], !0), op2 = distExports.removeOp([unitId, subUnitId, "order", this._getDrawingOrder(unitId, subUnitId).indexOf(drawingId)], !0), op = [op1, op2].reduce(distExports.type.compose, null), invertOp = distExports.type.invertWithDoc(op, this.drawingManagerData);
+    return { op, invertOp };
   }
-  _updateByParam(e) {
-    const { unitId: n, subUnitId: t, drawingId: r } = e, u = this._establishDrawingMap(n, t, r);
-    if (u == null)
+  _updateByParam(updateParam) {
+    const { unitId, subUnitId, drawingId } = updateParam, object = this._establishDrawingMap(unitId, subUnitId, drawingId);
+    if (object == null)
       return { op: [], invertOp: [] };
-    const l = this._getUpdateParamCompareOp(e, u).reduce(V.type.compose, null), E = V.type.invertWithDoc(l, this.drawingManagerData);
-    return { op: l, invertOp: E };
+    const op = this._getUpdateParamCompareOp(updateParam, object).reduce(distExports.type.compose, null), invertOp = distExports.type.invertWithDoc(op, this.drawingManagerData);
+    return { op, invertOp };
   }
   // private _initializeDrawingData(updateParam: T, oldParam: T) {
   //     Object.keys(updateParam).forEach((key) => {
@@ -1860,22 +1903,22 @@ class on {
   //         }
   //     });
   // }
-  _getUpdateParamCompareOp(e, n) {
-    const { unitId: t, subUnitId: r, drawingId: u } = e, o = [];
-    return Object.keys(e).forEach((l) => {
-      const E = e[l], x = n[l];
-      x !== E && o.push(
-        V.replaceOp([t, r, "data", u, l], x, E)
+  _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(
+        distExports.replaceOp([unitId, subUnitId, "data", drawingId, key], oldVal, newVal)
       );
-    }), o;
+    }), ops;
   }
-  _getDrawingData(e, n) {
-    var t, r;
-    return ((r = (t = this.drawingManagerData[e]) == null ? void 0 : t[n]) == null ? void 0 : r.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, n) {
-    var t, r;
-    return ((r = (t = this.drawingManagerData[e]) == null ? void 0 : t[n]) == null ? void 0 : r.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;
@@ -1883,85 +1926,89 @@ class on {
   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 an extends on {
-}
-function bn({ unitId: a, subUnitId: e, drawingId: n }, t) {
-  return typeof t == "number" ? `${a}#-#${e}#-#${n}#-#${t}` : `${a}#-#${e}#-#${n}`;
-}
-const vn = async (a) => new Promise((e, n) => {
-  const t = new Image();
-  t.src = a, t.onload = () => {
-    e({
-      width: t.width,
-      height: t.height,
-      image: t
+__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
     });
-  }, t.onerror = (r) => {
-    n(r);
+  }, image.onerror = (error) => {
+    reject(error);
   };
-}), Ut = Wt("univer.drawing-manager.service"), ln = {
+}), "getImageSize"), IDrawingManagerService = createIdentifier("univer.drawing-manager.service"), SetDrawingSelectedOperation = {
   id: "drawing.operation.set-drawing-selected",
-  type: Gt.OPERATION,
-  handler: (a, e) => {
-    const n = a.get(Ut);
-    return e == null ? !1 : (n.focusDrawing(e), !0);
-  }
-}, un = "drawing.config", Tt = {};
-class dn {
+  type: CommandType.OPERATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const drawingManagerService = accessor.get(IDrawingManagerService);
+    return params == null ? !1 : (drawingManagerService.focusDrawing(params), !0);
+  }, "handler")
+}, DRAWING_PLUGIN_CONFIG_KEY = "drawing.config", defaultPluginConfig = {}, _ImageIoService = class _ImageIoService {
   constructor() {
-    F(this, "_waitCount", 0);
-    F(this, "_change$", new ve());
-    F(this, "change$", this._change$);
-    F(this, "_imageSourceCache", /* @__PURE__ */ new Map());
-  }
-  setWaitCount(e) {
-    this._waitCount = e, this._change$.next(e);
-  }
-  getImageSourceCache(e, n) {
-    if (n === at.BASE64) {
-      const t = new Image();
-      return t.src = e, t;
+    __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, n, t) {
-    n === at.BASE64 || t == null || this._imageSourceCache.set(e, t);
+  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((n, t) => {
-      if (!Zt.includes(e.type)) {
-        t(new Error(Qe.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 > Yt) {
-        t(new Error(Qe.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
+      if (imageFile.size > DRAWING_IMAGE_ALLOW_SIZE) {
+        reject(new Error(ImageUploadStatusType.ERROR_EXCEED_SIZE)), this._decreaseWaiting();
         return;
       }
-      const r = new FileReader();
-      r.readAsDataURL(e), r.onload = (u) => {
-        var E;
-        const o = (E = u.target) == null ? void 0 : E.result;
-        if (o == null) {
-          t(new Error(Qe.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 l = Lt.generateRandomId(6);
-        n({
-          imageId: l,
-          imageSourceType: at.BASE64,
-          source: o,
-          base64Cache: o,
-          status: Qe.SUCCUSS
+        const imageId = Tools.generateRandomId(6);
+        resolve({
+          imageId,
+          imageSourceType: ImageSourceType.BASE64,
+          source: replaceSrc,
+          base64Cache: replaceSrc,
+          status: ImageUploadStatusType.SUCCUSS
         }), this._decreaseWaiting();
       };
     });
@@ -1969,60 +2016,62 @@ class dn {
   _decreaseWaiting() {
     this._waitCount -= 1, this._change$.next(this._waitCount);
   }
-}
-var cn = Object.defineProperty, fn = Object.getOwnPropertyDescriptor, hn = (a, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? fn(e, n) : e, u = a.length - 1, o; u >= 0; u--)
-    (o = a[u]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && cn(e, n, r), r;
-}, ct = (a, e) => (n, t) => e(n, t, a);
-const pn = "UNIVER_DRAWING_PLUGIN";
-var ft;
-let At = (ft = class extends Ft {
-  constructor(a = Tt, e, n, t) {
-    super(), this._config = a, this._injector = e, this._configService = n, this._commandService = t;
-    const { ...r } = Vt(
+};
+__name(_ImageIoService, "ImageIoService");
+let ImageIoService = _ImageIoService;
+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 = "UNIVER_DRAWING_PLUGIN";
+var _a;
+let UniverDrawingPlugin = (_a = class extends Plugin {
+  constructor(_config = defaultPluginConfig, _injector, _configService, _commandService) {
+    super(), this._config = _config, this._injector = _injector, this._configService = _configService, this._commandService = _commandService;
+    const { ...rest } = merge(
       {},
-      Tt,
+      defaultPluginConfig,
       this._config
     );
-    this._configService.setConfig(un, r);
+    this._configService.setConfig(DRAWING_PLUGIN_CONFIG_KEY, rest);
   }
   onStarting() {
     this._initCommands(), this._initDependencies();
   }
   _initDependencies() {
-    var n;
-    Ht([
-      [Jt, { useClass: dn }],
-      [Ut, { useClass: an }]
-    ], (n = this._config) == null ? void 0 : n.override).forEach((t) => this._injector.add(t));
+    var _a2;
+    mergeOverrideWithDependencies([
+      [IImageIoService, { useClass: ImageIoService }],
+      [IDrawingManagerService, { useClass: DrawingManagerService }]
+    ], (_a2 = this._config) == null ? void 0 : _a2.override).forEach((d) => this._injector.add(d));
   }
   _initCommands() {
     [
-      ln
-    ].forEach((a) => this.disposeWithMe(this._commandService.registerCommand(a)));
-  }
-}, F(ft, "pluginName", pn), ft);
-At = hn([
-  ct(1, qt(Kt)),
-  ct(2, zt),
-  ct(3, Xt)
-], At);
+      SetDrawingSelectedOperation
+    ].forEach((command) => this.disposeWithMe(this._commandService.registerCommand(command)));
+  }
+}, __name(_a, "UniverDrawingPlugin"), __publicField(_a, "pluginName", PLUGIN_NAME), _a);
+UniverDrawingPlugin = __decorateClass([
+  __decorateParam(1, Inject(Injector)),
+  __decorateParam(2, IConfigService),
+  __decorateParam(3, ICommandService)
+], UniverDrawingPlugin);
 export {
-  Zt as DRAWING_IMAGE_ALLOW_IMAGE_LIST,
-  Yt as DRAWING_IMAGE_ALLOW_SIZE,
-  wn as DRAWING_IMAGE_COUNT_LIMIT,
-  On as DRAWING_IMAGE_HEIGHT_LIMIT,
-  mn as DRAWING_IMAGE_WIDTH_LIMIT,
-  an as DrawingManagerService,
-  Ut as IDrawingManagerService,
-  En as IImageIoService,
-  dn as ImageIoService,
-  Dn as ImageSourceType,
-  Pn as ImageUploadStatusType,
-  ln as SetDrawingSelectedOperation,
-  on as UnitDrawingService,
-  At as UniverDrawingPlugin,
-  bn as getDrawingShapeKeyByDrawingSearch,
-  vn as getImageSize
+  DRAWING_IMAGE_ALLOW_IMAGE_LIST,
+  DRAWING_IMAGE_ALLOW_SIZE,
+  DRAWING_IMAGE_COUNT_LIMIT,
+  DRAWING_IMAGE_HEIGHT_LIMIT,
+  DRAWING_IMAGE_WIDTH_LIMIT,
+  DrawingManagerService,
+  IDrawingManagerService,
+  IImageIoService2 as IImageIoService,
+  ImageIoService,
+  ImageSourceType2 as ImageSourceType,
+  ImageUploadStatusType2 as ImageUploadStatusType,
+  SetDrawingSelectedOperation,
+  UnitDrawingService,
+  UniverDrawingPlugin,
+  getDrawingShapeKeyByDrawingSearch,
+  getImageSize
 };