pptx-svelte-viewer 0.1.3 → 0.2.0

package/dist/yjs-CE9F053g.js

@@ -0,0 +1,3473 @@
+var T = () => /* @__PURE__ */ new Map(), me = (e) => {
+  const t = T();
+  return e.forEach((r, n) => {
+    t.set(n, r);
+  }), t;
+}, J = (e, t, r) => {
+  let n = e.get(t);
+  return n === void 0 && e.set(t, n = r()), n;
+}, ms = (e, t) => {
+  const r = [];
+  for (const [n, s] of e) r.push(t(s, n));
+  return r;
+}, ys = (e, t) => {
+  for (const [r, n] of e) if (t(n, r)) return !0;
+  return !1;
+}, K = () => /* @__PURE__ */ new Set(), ce = (e) => e[e.length - 1], ks = (e, t) => {
+  for (let r = 0; r < t.length; r++) e.push(t[r]);
+}, Y = Array.from, Re = (e, t) => {
+  for (let r = 0; r < e.length; r++) if (!t(e[r], r, e)) return !1;
+  return !0;
+}, Rr = (e, t) => {
+  for (let r = 0; r < e.length; r++) if (t(e[r], r, e)) return !0;
+  return !1;
+}, _s = (e, t) => {
+  const r = new Array(e);
+  for (let n = 0; n < e; n++) r[n] = t(n, r);
+  return r;
+}, zt = Array.isArray, bs = class {
+  constructor() {
+    this._observers = T();
+  }
+  on(e, t) {
+    return J(this._observers, e, K).add(t), t;
+  }
+  once(e, t) {
+    const r = (...n) => {
+      this.off(e, r), t(...n);
+    };
+    this.on(e, r);
+  }
+  off(e, t) {
+    const r = this._observers.get(e);
+    r !== void 0 && (r.delete(t), r.size === 0 && this._observers.delete(e));
+  }
+  emit(e, t) {
+    return Y((this._observers.get(e) || T()).values()).forEach((r) => r(...t));
+  }
+  destroy() {
+    this._observers = T();
+  }
+}, Ho = class {
+  constructor() {
+    this._observers = T();
+  }
+  on(e, t) {
+    J(this._observers, e, K).add(t);
+  }
+  once(e, t) {
+    const r = (...n) => {
+      this.off(e, r), t(...n);
+    };
+    this.on(e, r);
+  }
+  off(e, t) {
+    const r = this._observers.get(e);
+    r !== void 0 && (r.delete(t), r.size === 0 && this._observers.delete(e));
+  }
+  emit(e, t) {
+    return Y((this._observers.get(e) || T()).values()).forEach((r) => r(...t));
+  }
+  destroy() {
+    this._observers = T();
+  }
+}, B = Math.floor, xt = Math.abs, zo = Math.log10, Br = (e, t) => e < t ? e : t, Z = (e, t) => e > t ? e : t, Ko = Number.isNaN, Wo = Math.pow, Vr = (e) => e !== 0 ? e < 0 : 1 / e < 0, Fr = Date.now, V = (e) => new Error(e), M = () => {
+  throw V("Method unimplemented");
+}, N = () => {
+  throw V("Unexpected case");
+};
+var Ss = 1 << 17, Cs = 1 << 18, Es = 1 << 19, Ds = 1 << 20, As = 1 << 21, Is = 1 << 22, Ts = 1 << 23, Os = 1 << 24, xs = 1 << 25, Ls = 1 << 26, $s = 1 << 27, Ns = 1 << 28, Ms = 1 << 29, Us = 1 << 30;
+var qo = Ss - 1, Zo = Cs - 1, Qo = Es - 1, Po = Ds - 1, tc = As - 1, ec = Is - 1, rc = Ts - 1, nc = Os - 1, sc = xs - 1, ic = Ls - 1, lc = $s - 1, oc = Ns - 1, cc = Ms - 1, ac = Us - 1;
+var hc = crypto.subtle, Rs = crypto.getRandomValues.bind(crypto), uc = Math.random, jr = () => Rs(/* @__PURE__ */ new Uint32Array(1))[0], Bs = "10000000-1000-4000-8000-100000000000", Vs = () => Bs.replace(/[018]/g, (e) => (e ^ jr() & 15 >> e / 4).toString(16)), Rt = Number.MAX_SAFE_INTEGER, fr = Number.MIN_SAFE_INTEGER, Fs = Number.isInteger || ((e) => typeof e == "number" && isFinite(e) && B(e) === e), dc = Number.isNaN, fc = Number.parseInt, Be = String.fromCharCode, gc = String.fromCodePoint, pc = Be(65535), js = (e) => e.toLowerCase(), Ys = /^\s*/g, Js = (e) => e.replace(Ys, ""), Xs = /([A-Z])/g, gr = (e, t) => Js(e.replace(Xs, (r) => `${t}${js(r)}`)), Gs = (e) => {
+  const t = unescape(encodeURIComponent(e)), r = t.length, n = new Uint8Array(r);
+  for (let s = 0; s < r; s++) n[s] = t.codePointAt(s);
+  return n;
+}, pt = typeof TextEncoder < "u" ? new TextEncoder() : null, Hs = (e) => pt.encode(e), zs = pt ? Hs : Gs, gt = typeof TextDecoder > "u" ? null : new TextDecoder("utf-8", {
+  fatal: !0,
+  ignoreBOM: !0
+});
+gt && gt.decode(/* @__PURE__ */ new Uint8Array()).length === 1 && (gt = null);
+var Ks = (e, t) => _s(t, () => e).join(""), St = class {
+  constructor() {
+    this.cpos = 0, this.cbuf = /* @__PURE__ */ new Uint8Array(100), this.bufs = [];
+  }
+}, Kt = () => new St(), Ws = (e) => {
+  let t = e.cpos;
+  for (let r = 0; r < e.bufs.length; r++) t += e.bufs[r].length;
+  return t;
+}, R = (e) => {
+  const t = new Uint8Array(Ws(e));
+  let r = 0;
+  for (let n = 0; n < e.bufs.length; n++) {
+    const s = e.bufs[n];
+    t.set(s, r), r += s.length;
+  }
+  return t.set(new Uint8Array(e.cbuf.buffer, 0, e.cpos), r), t;
+}, qs = (e, t) => {
+  const r = e.cbuf.length;
+  r - e.cpos < t && (e.bufs.push(new Uint8Array(e.cbuf.buffer, 0, e.cpos)), e.cbuf = new Uint8Array(Z(r, t) * 2), e.cpos = 0);
+}, _ = (e, t) => {
+  const r = e.cbuf.length;
+  e.cpos === r && (e.bufs.push(e.cbuf), e.cbuf = new Uint8Array(r * 2), e.cpos = 0), e.cbuf[e.cpos++] = t;
+}, ye = _, v = (e, t) => {
+  for (; t > 127; )
+    _(e, 128 | 127 & t), t = B(t / 128);
+  _(e, 127 & t);
+}, Ve = (e, t) => {
+  const r = Vr(t);
+  for (r && (t = -t), _(e, (t > 63 ? 128 : 0) | (r ? 64 : 0) | 63 & t), t = B(t / 64); t > 0; )
+    _(e, (t > 127 ? 128 : 0) | 127 & t), t = B(t / 128);
+}, ke = /* @__PURE__ */ new Uint8Array(3e4), Zs = ke.length / 3, Qs = (e, t) => {
+  if (t.length < Zs) {
+    const r = pt.encodeInto(t, ke).written || 0;
+    v(e, r);
+    for (let n = 0; n < r; n++) _(e, ke[n]);
+  } else O(e, zs(t));
+}, Ps = (e, t) => {
+  const r = unescape(encodeURIComponent(t)), n = r.length;
+  v(e, n);
+  for (let s = 0; s < n; s++) _(e, r.codePointAt(s));
+}, rt = pt && pt.encodeInto ? Qs : Ps, Wt = (e, t) => {
+  const r = e.cbuf.length, n = e.cpos, s = Br(r - n, t.length), i = t.length - s;
+  e.cbuf.set(t.subarray(0, s), n), e.cpos += s, i > 0 && (e.bufs.push(e.cbuf), e.cbuf = new Uint8Array(Z(r * 2, i)), e.cbuf.set(t.subarray(s)), e.cpos = i);
+}, O = (e, t) => {
+  v(e, t.byteLength), Wt(e, t);
+}, Fe = (e, t) => {
+  qs(e, t);
+  const r = new DataView(e.cbuf.buffer, e.cpos, t);
+  return e.cpos += t, r;
+}, ti = (e, t) => Fe(e, 4).setFloat32(0, t, !1), ei = (e, t) => Fe(e, 8).setFloat64(0, t, !1), ri = (e, t) => Fe(e, 8).setBigInt64(0, t, !1), pr = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4)), ni = (e) => (pr.setFloat32(0, e), pr.getFloat32(0) === e), vt = (e, t) => {
+  switch (typeof t) {
+    case "string":
+      _(e, 119), rt(e, t);
+      break;
+    case "number":
+      Fs(t) && xt(t) <= 2147483647 ? (_(e, 125), Ve(e, t)) : ni(t) ? (_(e, 124), ti(e, t)) : (_(e, 123), ei(e, t));
+      break;
+    case "bigint":
+      _(e, 122), ri(e, t);
+      break;
+    case "object":
+      if (t === null) _(e, 126);
+      else if (zt(t)) {
+        _(e, 117), v(e, t.length);
+        for (let r = 0; r < t.length; r++) vt(e, t[r]);
+      } else if (t instanceof Uint8Array)
+        _(e, 116), O(e, t);
+      else {
+        _(e, 118);
+        const r = Object.keys(t);
+        v(e, r.length);
+        for (let n = 0; n < r.length; n++) {
+          const s = r[n];
+          rt(e, s), vt(e, t[s]);
+        }
+      }
+      break;
+    case "boolean":
+      _(e, t ? 120 : 121);
+      break;
+    default:
+      _(e, 127);
+  }
+}, vr = class extends St {
+  constructor(e) {
+    super(), this.w = e, this.s = null, this.count = 0;
+  }
+  write(e) {
+    this.s === e ? this.count++ : (this.count > 0 && v(this, this.count - 1), this.count = 1, this.w(this, e), this.s = e);
+  }
+}, wr = (e) => {
+  e.count > 0 && (Ve(e.encoder, e.count === 1 ? e.s : -e.s), e.count > 1 && v(e.encoder, e.count - 2));
+}, Lt = class {
+  constructor() {
+    this.encoder = new St(), this.s = 0, this.count = 0;
+  }
+  write(e) {
+    this.s === e ? this.count++ : (wr(this), this.count = 1, this.s = e);
+  }
+  toUint8Array() {
+    return wr(this), R(this.encoder);
+  }
+}, mr = (e) => {
+  if (e.count > 0) {
+    const t = e.diff * 2 + (e.count === 1 ? 0 : 1);
+    Ve(e.encoder, t), e.count > 1 && v(e.encoder, e.count - 2);
+  }
+}, ae = class {
+  constructor() {
+    this.encoder = new St(), this.s = 0, this.count = 0, this.diff = 0;
+  }
+  write(e) {
+    this.diff === e - this.s ? (this.s = e, this.count++) : (mr(this), this.count = 1, this.diff = e - this.s, this.s = e);
+  }
+  toUint8Array() {
+    return mr(this), R(this.encoder);
+  }
+}, si = class {
+  constructor() {
+    this.sarr = [], this.s = "", this.lensE = new Lt();
+  }
+  write(e) {
+    this.s += e, this.s.length > 19 && (this.sarr.push(this.s), this.s = ""), this.lensE.write(e.length);
+  }
+  toUint8Array() {
+    const e = new St();
+    return this.sarr.push(this.s), this.s = "", rt(e, this.sarr.join("")), Wt(e, this.lensE.toUint8Array()), R(e);
+  }
+}, Yr = V("Unexpected end of array"), Jr = V("Integer out of Range"), qt = class {
+  constructor(e) {
+    this.arr = e, this.pos = 0;
+  }
+}, ht = (e) => new qt(e), ii = (e) => e.pos !== e.arr.length, li = (e, t) => {
+  const r = new Uint8Array(e.arr.buffer, e.pos + e.arr.byteOffset, t);
+  return e.pos += t, r;
+}, x = (e) => li(e, p(e)), lt = (e) => e.arr[e.pos++], p = (e) => {
+  let t = 0, r = 1;
+  const n = e.arr.length;
+  for (; e.pos < n; ) {
+    const s = e.arr[e.pos++];
+    if (t = t + (s & 127) * r, r *= 128, s < 128) return t;
+    if (t > Rt) throw Jr;
+  }
+  throw Yr;
+}, je = (e) => {
+  let t = e.arr[e.pos++], r = t & 63, n = 64;
+  const s = (t & 64) > 0 ? -1 : 1;
+  if ((t & 128) === 0) return s * r;
+  const i = e.arr.length;
+  for (; e.pos < i; ) {
+    if (t = e.arr[e.pos++], r = r + (t & 127) * n, n *= 128, t < 128) return s * r;
+    if (r > Rt) throw Jr;
+  }
+  throw Yr;
+}, oi = (e) => {
+  let t = p(e);
+  if (t === 0) return "";
+  {
+    let r = String.fromCodePoint(lt(e));
+    if (--t < 100) for (; t--; ) r += String.fromCodePoint(lt(e));
+    else for (; t > 0; ) {
+      const n = t < 1e4 ? t : 1e4, s = e.arr.subarray(e.pos, e.pos + n);
+      e.pos += n, r += String.fromCodePoint.apply(null, s), t -= n;
+    }
+    return decodeURIComponent(escape(r));
+  }
+}, ci = (e) => gt.decode(x(e)), nt = gt ? ci : oi, Ye = (e, t) => {
+  const r = new DataView(e.arr.buffer, e.arr.byteOffset + e.pos, t);
+  return e.pos += t, r;
+}, ai = (e) => Ye(e, 4).getFloat32(0, !1), hi = (e) => Ye(e, 8).getFloat64(0, !1), ui = (e) => Ye(e, 8).getBigInt64(0, !1), di = [
+  (e) => {
+  },
+  (e) => null,
+  je,
+  ai,
+  hi,
+  ui,
+  (e) => !1,
+  (e) => !0,
+  nt,
+  (e) => {
+    const t = p(e), r = {};
+    for (let n = 0; n < t; n++) {
+      const s = nt(e);
+      r[s] = wt(e);
+    }
+    return r;
+  },
+  (e) => {
+    const t = p(e), r = [];
+    for (let n = 0; n < t; n++) r.push(wt(e));
+    return r;
+  },
+  x
+], wt = (e) => di[127 - lt(e)](e), yr = class extends qt {
+  constructor(e, t) {
+    super(e), this.reader = t, this.s = null, this.count = 0;
+  }
+  read() {
+    return this.count === 0 && (this.s = this.reader(this), ii(this) ? this.count = p(this) + 1 : this.count = -1), this.count--, this.s;
+  }
+}, $t = class extends qt {
+  constructor(e) {
+    super(e), this.s = 0, this.count = 0;
+  }
+  read() {
+    if (this.count === 0) {
+      this.s = je(this);
+      const e = Vr(this.s);
+      this.count = 1, e && (this.s = -this.s, this.count = p(this) + 2);
+    }
+    return this.count--, this.s;
+  }
+}, he = class extends qt {
+  constructor(e) {
+    super(e), this.s = 0, this.count = 0, this.diff = 0;
+  }
+  read() {
+    if (this.count === 0) {
+      const e = je(this), t = e & 1;
+      this.diff = B(e / 2), this.count = 1, t && (this.count = p(this) + 2);
+    }
+    return this.s += this.diff, this.count--, this.s;
+  }
+}, fi = class {
+  constructor(e) {
+    this.decoder = new $t(e), this.str = nt(this.decoder), this.spos = 0;
+  }
+  read() {
+    const e = this.spos + this.decoder.read(), t = this.str.slice(this.spos, e);
+    return this.spos = e, t;
+  }
+}, kr = (e) => e === void 0 ? null : e, gi = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  setItem(e, t) {
+    this.map.set(e, t);
+  }
+  getItem(e) {
+    return this.map.get(e);
+  }
+}, Xr = new gi(), Je = !0;
+try {
+  typeof localStorage < "u" && localStorage && (Xr = localStorage, Je = !1);
+} catch {
+}
+var pi = Xr, vc = (e) => Je || addEventListener("storage", e), wc = (e) => Je || removeEventListener("storage", e), mt = /* @__PURE__ */ Symbol("Equality"), Gr = (e, t) => e === t || !!e?.[mt]?.(t) || !1, vi = (e) => typeof e == "object", wi = Object.assign, mi = Object.keys, yi = (e, t) => {
+  for (const r in e) t(e[r], r);
+}, mc = (e, t) => {
+  const r = [];
+  for (const n in e) r.push(t(e[n], n));
+  return r;
+}, Bt = (e) => mi(e).length, ki = (e) => {
+  for (const t in e) return !1;
+  return !0;
+}, Ct = (e, t) => {
+  for (const r in e) if (!t(e[r], r)) return !1;
+  return !0;
+}, Xe = (e, t) => Object.prototype.hasOwnProperty.call(e, t), _i = (e, t) => e === t || Bt(e) === Bt(t) && Ct(e, (r, n) => (r !== void 0 || Xe(t, n)) && Gr(t[n], r)), bi = Object.freeze, Hr = (e) => {
+  for (const t in e) {
+    const r = e[t];
+    (typeof r == "object" || typeof r == "function") && Hr(e[t]);
+  }
+  return bi(e);
+}, Ge = (e, t, r = 0) => {
+  try {
+    for (; r < e.length; r++) e[r](...t);
+  } finally {
+    r < e.length && Ge(e, t, r + 1);
+  }
+}, Si = () => {
+}, Ci = (e) => e, Nt = (e, t) => {
+  if (e === t) return !0;
+  if (e == null || t == null || e.constructor !== t.constructor && (e.constructor || Object) !== (t.constructor || Object)) return !1;
+  if (e[mt] != null) return e[mt](t);
+  switch (e.constructor) {
+    case ArrayBuffer:
+      e = new Uint8Array(e), t = new Uint8Array(t);
+    case Uint8Array:
+      if (e.byteLength !== t.byteLength) return !1;
+      for (let r = 0; r < e.length; r++) if (e[r] !== t[r]) return !1;
+      break;
+    case Set:
+      if (e.size !== t.size) return !1;
+      for (const r of e) if (!t.has(r)) return !1;
+      break;
+    case Map:
+      if (e.size !== t.size) return !1;
+      for (const r of e.keys()) if (!t.has(r) || !Nt(e.get(r), t.get(r))) return !1;
+      break;
+    case void 0:
+    case Object:
+      if (Bt(e) !== Bt(t)) return !1;
+      for (const r in e) if (!Xe(e, r) || !Nt(e[r], t[r])) return !1;
+      break;
+    case Array:
+      if (e.length !== t.length) return !1;
+      for (let r = 0; r < e.length; r++) if (!Nt(e[r], t[r])) return !1;
+      break;
+    default:
+      return !1;
+  }
+  return !0;
+}, Ei = (e, t) => t.includes(e), ot = typeof process < "u" && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process < "u" ? process : 0) === "[object process]", zr = typeof window < "u" && typeof document < "u" && !ot, yc = typeof navigator < "u" ? /Mac/.test(navigator.platform) : !1, U, Di = [], Ai = () => {
+  if (U === void 0) if (ot) {
+    U = T();
+    const e = process.argv;
+    let t = null;
+    for (let r = 0; r < e.length; r++) {
+      const n = e[r];
+      n[0] === "-" ? (t !== null && U.set(t, ""), t = n) : t !== null ? (U.set(t, n), t = null) : Di.push(n);
+    }
+    t !== null && U.set(t, "");
+  } else typeof location == "object" ? (U = T(), (location.search || "?").slice(1).split("&").forEach((e) => {
+    if (e.length !== 0) {
+      const [t, r] = e.split("=");
+      U.set(`--${gr(t, "-")}`, r), U.set(`-${gr(t, "-")}`, r);
+    }
+  })) : U = T();
+  return U;
+}, _e = (e) => Ai().has(e), yt = (e) => kr(ot ? process.env[e.toUpperCase().replaceAll("-", "_")] : pi.getItem(e)), Kr = (e) => _e("--" + e) || yt(e) !== null, Ii = Kr("production"), Ti = ot && Ei(process.env.FORCE_COLOR, [
+  "true",
+  "1",
+  "2"
+]), Oi = Ti || !_e("--no-colors") && !Kr("no-color") && (!ot || process.stdout.isTTY) && (!ot || _e("--color") || yt("COLORTERM") !== null || (yt("TERM") || "").includes("color")), xi = class {
+  constructor(e, t) {
+    this.left = e, this.right = t;
+  }
+}, j = (e, t) => new xi(e, t), Wr = (e) => new Uint8Array(e), Li = (e, t, r) => new Uint8Array(e, t, r), kc = (e) => new Uint8Array(e), $i = (e) => {
+  let t = "";
+  for (let r = 0; r < e.byteLength; r++) t += Be(e[r]);
+  return btoa(t);
+}, Ni = (e) => Buffer.from(e.buffer, e.byteOffset, e.byteLength).toString("base64"), Mi = (e) => {
+  const t = atob(e), r = Wr(t.length);
+  for (let n = 0; n < t.length; n++) r[n] = t.charCodeAt(n);
+  return r;
+}, Ui = (e) => {
+  const t = Buffer.from(e, "base64");
+  return Li(t.buffer, t.byteOffset, t.byteLength);
+}, _c = zr ? $i : Ni, bc = zr ? Mi : Ui, Ri = (e) => {
+  const t = Wr(e.byteLength);
+  return t.set(e), t;
+}, _r = (e) => e.next() >= 0.5, ue = (e, t, r) => B(e.next() * (r + 1 - t) + t), qr = (e, t, r) => B(e.next() * (r + 1 - t) + t), He = (e, t, r) => qr(e, t, r), Bi = (e) => Be(He(e, 97, 122)), Vi = (e, t = 0, r = 20) => {
+  const n = He(e, t, r);
+  let s = "";
+  for (let i = 0; i < n; i++) s += Bi(e);
+  return s;
+}, de = (e, t) => t[He(e, 0, t.length - 1)], Fi = /* @__PURE__ */ Symbol("0schema"), ji = class {
+  constructor() {
+    this._rerrs = [];
+  }
+  extend(e, t, r, n = null) {
+    this._rerrs.push({
+      path: e,
+      expected: t,
+      has: r,
+      message: n
+    });
+  }
+  toString() {
+    const e = [];
+    for (let t = this._rerrs.length - 1; t > 0; t--) {
+      const r = this._rerrs[t];
+      e.push(Ks(" ", (this._rerrs.length - t) * 2) + `${r.path != null ? `[${r.path}] ` : ""}${r.has} doesn't match ${r.expected}. ${r.message}`);
+    }
+    return e.join(`
+`);
+  }
+}, be = (e, t) => e === t ? !0 : e == null || t == null || e.constructor !== t.constructor ? !1 : e[mt] ? Gr(e, t) : zt(e) ? Re(e, (r) => Rr(t, (n) => be(r, n))) : vi(e) ? Ct(e, (r, n) => be(r, t[n])) : !1, I = class {
+  static _dilutes = !1;
+  extends(e) {
+    let [t, r] = [this.shape, e.shape];
+    return this.constructor._dilutes && ([r, t] = [t, r]), be(t, r);
+  }
+  equals(e) {
+    return this.constructor === e.constructor && Nt(this.shape, e.shape);
+  }
+  [Fi]() {
+    return !0;
+  }
+  [mt](e) {
+    return this.equals(e);
+  }
+  validate(e) {
+    return this.check(e);
+  }
+  /* c8 ignore start */
+  check(e, t) {
+    M();
+  }
+  /* c8 ignore stop */
+  get nullable() {
+    return ut(this, te);
+  }
+  get optional() {
+    return new Pr(this);
+  }
+  cast(e) {
+    return br(e, this), e;
+  }
+  expect(e) {
+    return br(e, this), e;
+  }
+}, ze = class extends I {
+  constructor(e, t) {
+    super(), this.shape = e, this._c = t;
+  }
+  check(e, t = void 0) {
+    const r = e?.constructor === this.shape && (this._c == null || this._c(e));
+    return !r && t?.extend(null, this.shape.name, e?.constructor.name, e?.constructor !== this.shape ? "Constructor match failed" : "Check failed"), r;
+  }
+}, k = (e, t = null) => new ze(e, t), Sc = k(ze), Ke = class extends I {
+  constructor(e) {
+    super(), this.shape = e;
+  }
+  check(e, t) {
+    const r = this.shape(e);
+    return !r && t?.extend(null, "custom prop", e?.constructor.name, "failed to check custom prop"), r;
+  }
+}, S = (e) => new Ke(e), Cc = k(Ke), Zt = class extends I {
+  constructor(e) {
+    super(), this.shape = e;
+  }
+  check(e, t) {
+    const r = this.shape.some((n) => n === e);
+    return !r && t?.extend(null, this.shape.join(" | "), e.toString()), r;
+  }
+}, Qt = (...e) => new Zt(e), Zr = k(Zt), Yi = RegExp.escape || ((e) => e.replace(/[().|&,$^[\]]/g, (t) => "\\" + t)), Qr = (e) => {
+  if (ct.check(e)) return [Yi(e)];
+  if (Zr.check(e)) return e.shape.map((t) => t + "");
+  if (dn.check(e)) return ["[+-]?\\d+.?\\d*"];
+  if (fn.check(e)) return [".*"];
+  if (Vt.check(e)) return e.shape.map(Qr).flat(1);
+  N();
+}, Ji = class extends I {
+  constructor(e) {
+    super(), this.shape = e, this._r = new RegExp("^" + e.map(Qr).map((t) => `(${t.join("|")})`).join("") + "$");
+  }
+  check(e, t) {
+    const r = this._r.exec(e) != null;
+    return !r && t?.extend(null, this._r.toString(), e.toString(), "String doesn't match string template."), r;
+  }
+}, Ec = k(Ji), Xi = /* @__PURE__ */ Symbol("optional"), Pr = class extends I {
+  constructor(e) {
+    super(), this.shape = e;
+  }
+  check(e, t) {
+    const r = e === void 0 || this.shape.check(e);
+    return !r && t?.extend(null, "undefined (optional)", "()"), r;
+  }
+  get [Xi]() {
+    return !0;
+  }
+}, Gi = k(Pr), tn = class extends I {
+  check(e, t) {
+    return t?.extend(null, "never", typeof e), !1;
+  }
+}, Dc = new tn(), Ac = k(tn), en = class rn extends I {
+  constructor(t, r = !1) {
+    super(), this.shape = t, this._isPartial = r;
+  }
+  static _dilutes = !0;
+  get partial() {
+    return new rn(this.shape, !0);
+  }
+  check(t, r) {
+    return t == null ? (r?.extend(null, "object", "null"), !1) : Ct(this.shape, (n, s) => {
+      const i = this._isPartial && !Xe(t, s) || n.check(t[s], r);
+      return !i && r?.extend(s.toString(), n.toString(), typeof t[s], "Object property does not match"), i;
+    });
+  }
+}, Hi = (e) => new en(e), zi = k(en), Ki = S((e) => e != null && (e.constructor === Object || e.constructor == null)), nn = class extends I {
+  constructor(e, t) {
+    super(), this.shape = {
+      keys: e,
+      values: t
+    };
+  }
+  check(e, t) {
+    return e != null && Ct(e, (r, n) => {
+      const s = this.shape.keys.check(n, t);
+      return !s && t?.extend(n + "", "Record", typeof e, s ? "Key doesn't match schema" : "Value doesn't match value"), s && this.shape.values.check(r, t);
+    });
+  }
+}, sn = (e, t) => new nn(e, t), Wi = k(nn), ln = class extends I {
+  constructor(e) {
+    super(), this.shape = e;
+  }
+  check(e, t) {
+    return e != null && Ct(this.shape, (r, n) => {
+      const s = r.check(e[n], t);
+      return !s && t?.extend(n.toString(), "Tuple", typeof r), s;
+    });
+  }
+}, qi = (...e) => new ln(e), Ic = k(ln), on = class extends I {
+  constructor(e) {
+    super(), this.shape = e.length === 1 ? e[0] : new We(e);
+  }
+  check(e, t) {
+    const r = zt(e) && Re(e, (n) => this.shape.check(n));
+    return !r && t?.extend(null, "Array", ""), r;
+  }
+}, cn = (...e) => new on(e), Zi = k(on), Qi = S((e) => zt(e)), an = class extends I {
+  constructor(e, t) {
+    super(), this.shape = e, this._c = t;
+  }
+  check(e, t) {
+    const r = e instanceof this.shape && (this._c == null || this._c(e));
+    return !r && t?.extend(null, this.shape.name, e?.constructor.name), r;
+  }
+}, Pi = (e, t = null) => new an(e, t), Tc = k(an), tl = Pi(I), el = class extends I {
+  constructor(e) {
+    super(), this.len = e.length - 1, this.args = qi(...e.slice(-1)), this.res = e[this.len];
+  }
+  check(e, t) {
+    const r = e.constructor === Function && e.length <= this.len;
+    return !r && t?.extend(null, "function", typeof e), r;
+  }
+}, rl = k(el), nl = S((e) => typeof e == "function"), sl = class extends I {
+  constructor(e) {
+    super(), this.shape = e;
+  }
+  check(e, t) {
+    const r = Re(this.shape, (n) => n.check(e, t));
+    return !r && t?.extend(null, "Intersectinon", typeof e), r;
+  }
+}, Oc = k(sl, (e) => e.shape.length > 0), We = class extends I {
+  static _dilutes = !0;
+  constructor(e) {
+    super(), this.shape = e;
+  }
+  check(e, t) {
+    const r = Rr(this.shape, (n) => n.check(e, t));
+    return t?.extend(null, "Union", typeof e), r;
+  }
+}, ut = (...e) => e.findIndex((t) => Vt.check(t)) >= 0 ? ut(...e.map((t) => kt(t)).map((t) => Vt.check(t) ? t.shape : [t]).flat(1)) : e.length === 1 ? e[0] : new We(e), Vt = k(We), hn = () => !0, Ft = S(hn), il = k(Ke, (e) => e.shape === hn), qe = S((e) => typeof e == "bigint"), ll = S((e) => e === qe), un = S((e) => typeof e == "symbol"), xc = S((e) => e === un), st = S((e) => typeof e == "number"), dn = S((e) => e === st), ct = S((e) => typeof e == "string"), fn = S((e) => e === ct), Pt = S((e) => typeof e == "boolean"), ol = S((e) => e === Pt), gn = Qt(void 0), Lc = k(Zt, (e) => e.shape.length === 1 && e.shape[0] === void 0), $c = Qt(void 0), te = Qt(null), cl = k(Zt, (e) => e.shape.length === 1 && e.shape[0] === null), Nc = k(Uint8Array), Mc = k(ze, (e) => e.shape === Uint8Array), al = ut(st, ct, te, gn, qe, Pt, un), Uc = (() => {
+  const e = cn(Ft), t = sn(ct, Ft), r = ut(st, ct, te, Pt, e, t);
+  return e.shape = r, t.shape.values = r, r;
+})(), kt = (e) => {
+  if (tl.check(e)) return e;
+  if (Ki.check(e)) {
+    const t = {};
+    for (const r in e) t[r] = kt(e[r]);
+    return Hi(t);
+  } else {
+    if (Qi.check(e)) return ut(...e.map(kt));
+    if (al.check(e)) return Qt(e);
+    if (nl.check(e)) return k(e);
+  }
+  N();
+}, br = Ii ? () => {
+} : (e, t) => {
+  const r = new ji();
+  if (!t.check(e, r)) throw V(`Expected value to be of type ${t.constructor.name}.
+${r.toString()}`);
+}, hl = class {
+  constructor(e) {
+    this.patterns = [], this.$state = e;
+  }
+  if(e, t) {
+    return this.patterns.push({
+      if: kt(e),
+      h: t
+    }), this;
+  }
+  else(e) {
+    return this.if(Ft, e);
+  }
+  done() {
+    return (e, t) => {
+      for (let r = 0; r < this.patterns.length; r++) {
+        const n = this.patterns[r];
+        if (n.if.check(e)) return n.h(e, t);
+      }
+      throw V("Unhandled pattern");
+    };
+  }
+}, ul = (e) => new hl(e), pn = ul(Ft).if(dn, (e, t) => ue(t, fr, Rt)).if(fn, (e, t) => Vi(t)).if(ol, (e, t) => _r(t)).if(ll, (e, t) => BigInt(ue(t, fr, Rt))).if(Vt, (e, t) => tt(t, de(t, e.shape))).if(zi, (e, t) => {
+  const r = {};
+  for (const n in e.shape) {
+    let s = e.shape[n];
+    if (Gi.check(s)) {
+      if (_r(t)) continue;
+      s = s.shape;
+    }
+    r[n] = pn(s, t);
+  }
+  return r;
+}).if(Zi, (e, t) => {
+  const r = [], n = qr(t, 0, 42);
+  for (let s = 0; s < n; s++) r.push(tt(t, e.shape));
+  return r;
+}).if(Zr, (e, t) => de(t, e.shape)).if(cl, (e, t) => null).if(rl, (e, t) => {
+  const r = tt(t, e.res);
+  return () => r;
+}).if(il, (e, t) => tt(t, de(t, [
+  st,
+  ct,
+  te,
+  gn,
+  qe,
+  Pt,
+  cn(st),
+  sn(ut("a", "b", "c"), st)
+]))).if(Wi, (e, t) => {
+  const r = {}, n = ue(t, 0, 3);
+  for (let s = 0; s < n; s++) {
+    const i = tt(t, e.shape.keys);
+    r[i] = tt(t, e.shape.values);
+  }
+  return r;
+}).done(), tt = (e, t) => pn(kt(t), e), Q = typeof document < "u" ? document : {}, Rc = S((e) => e.nodeType === vl), Bc = typeof DOMParser < "u" ? new DOMParser() : null, Vc = S((e) => e.nodeType === fl), Fc = S((e) => e.nodeType === gl), dl = (e) => ms(e, (t, r) => `${r}:${t};`).join(""), fl = Q.ELEMENT_NODE, gl = Q.TEXT_NODE, jc = Q.CDATA_SECTION_NODE, Yc = Q.COMMENT_NODE, pl = Q.DOCUMENT_NODE, Jc = Q.DOCUMENT_TYPE_NODE, vl = Q.DOCUMENT_FRAGMENT_NODE, Xc = S((e) => e.nodeType === pl), wl = JSON.stringify, X = Symbol, vn = X(), wn = X(), mn = X(), ml = X(), yn = X(), kn = X(), _n = X(), ee = X(), bn = X(), yl = (e) => {
+  e.length === 1 && e[0]?.constructor === Function && (e = e[0]());
+  const t = [], r = [];
+  let n = 0;
+  for (; n < e.length; n++) {
+    const s = e[n];
+    if (s === void 0) break;
+    if (s.constructor === String || s.constructor === Number) t.push(s);
+    else if (s.constructor === Object) break;
+  }
+  for (n > 0 && r.push(t.join("")); n < e.length; n++) {
+    const s = e[n];
+    s instanceof Symbol || r.push(s);
+  }
+  return r;
+}, Sr = [
+  yn,
+  _n,
+  ee,
+  mn
+], fe = 0, Cr = Fr(), kl = (e, t) => {
+  const r = Sr[fe], n = yt("log"), s = n !== null && (n === "*" || n === "true" || new RegExp(n, "gi").test(t));
+  return fe = (fe + 1) % Sr.length, t += ": ", s ? (...i) => {
+    i.length === 1 && i[0]?.constructor === Function && (i = i[0]());
+    const l = Fr(), o = l - Cr;
+    Cr = l, e(r, t, bn, ...i.map((c) => {
+      switch (c != null && c.constructor === Uint8Array && (c = Array.from(c)), typeof c) {
+        case "string":
+        case "symbol":
+          return c;
+        default:
+          return wl(c);
+      }
+    }), r, " +" + o + "ms");
+  } : Si;
+}, _l = {
+  [vn]: j("font-weight", "bold"),
+  [wn]: j("font-weight", "normal"),
+  [mn]: j("color", "blue"),
+  [yn]: j("color", "green"),
+  [ml]: j("color", "grey"),
+  [kn]: j("color", "red"),
+  [_n]: j("color", "purple"),
+  [ee]: j("color", "orange"),
+  [bn]: j("color", "black")
+}, bl = (e) => {
+  e.length === 1 && e[0]?.constructor === Function && (e = e[0]());
+  const t = [], r = [], n = T();
+  let s = [], i = 0;
+  for (; i < e.length; i++) {
+    const l = e[i], o = _l[l];
+    if (o !== void 0) n.set(o.left, o.right);
+    else {
+      if (l === void 0) break;
+      if (l.constructor === String || l.constructor === Number) {
+        const c = dl(n);
+        i > 0 || c.length > 0 ? (t.push("%c" + l), r.push(c)) : t.push(l);
+      } else break;
+    }
+  }
+  for (i > 0 && (s = r, s.unshift(t.join(""))); i < e.length; i++) {
+    const l = e[i];
+    l instanceof Symbol || s.push(l);
+  }
+  return s;
+}, Sn = Oi ? bl : yl, Cn = (...e) => {
+  console.log(...Sn(e)), En.forEach((t) => t.print(e));
+}, Sl = (...e) => {
+  console.warn(...Sn(e)), e.unshift(ee), En.forEach((t) => t.print(e));
+}, En = K(), Gc = (e) => kl(Cn, e), Er = (e) => new Promise(e), Hc = Promise.all.bind(Promise), zc = (e) => Promise.reject(e), Kc = (e) => Promise.resolve(e), Dn = (e) => ({
+  [Symbol.iterator]() {
+    return this;
+  },
+  next: e
+}), Cl = (e, t) => Dn(() => {
+  let r;
+  do
+    r = e.next();
+  while (!r.done && !t(r.value));
+  return r;
+}), ge = (e, t) => Dn(() => {
+  const { done: r, value: n } = e.next();
+  return {
+    done: r,
+    value: r ? void 0 : t(n)
+  };
+}), re = class {
+  constructor(e, t) {
+    this.clock = e, this.len = t;
+  }
+}, Et = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map();
+  }
+}, An = (e, t, r) => t.clients.forEach((n, s) => {
+  const i = e.doc.store.clients.get(s);
+  if (i != null) {
+    const l = i[i.length - 1], o = l.id.clock + l.length;
+    for (let c = 0, h = n[c]; c < n.length && h.clock < o; h = n[++c]) Yn(e, i, h.clock, h.len, r);
+  }
+}), El = (e, t) => {
+  let r = 0, n = e.length - 1;
+  for (; r <= n; ) {
+    const s = B((r + n) / 2), i = e[s], l = i.clock;
+    if (l <= t) {
+      if (t < l + i.len) return s;
+      r = s + 1;
+    } else n = s - 1;
+  }
+  return null;
+}, In = (e, t) => {
+  const r = e.clients.get(t.client);
+  return r !== void 0 && El(r, t.clock) !== null;
+}, Ze = (e) => {
+  e.clients.forEach((t) => {
+    t.sort((s, i) => s.clock - i.clock);
+    let r, n;
+    for (r = 1, n = 1; r < t.length; r++) {
+      const s = t[n - 1], i = t[r];
+      s.clock + s.len >= i.clock ? t[n - 1] = new re(s.clock, Z(s.len, i.clock + i.len - s.clock)) : (n < r && (t[n] = i), n++);
+    }
+    t.length = n;
+  });
+}, Dl = (e) => {
+  const t = new Et();
+  for (let r = 0; r < e.length; r++) e[r].clients.forEach((n, s) => {
+    if (!t.clients.has(s)) {
+      const i = n.slice();
+      for (let l = r + 1; l < e.length; l++) ks(i, e[l].clients.get(s) || []);
+      t.clients.set(s, i);
+    }
+  });
+  return Ze(t), t;
+}, jt = (e, t, r, n) => {
+  J(e.clients, t, () => []).push(new re(r, n));
+}, Tn = () => new Et(), Al = (e) => {
+  const t = Tn();
+  return e.clients.forEach((r, n) => {
+    const s = [];
+    for (let i = 0; i < r.length; i++) {
+      const l = r[i];
+      if (l.deleted) {
+        const o = l.id.clock;
+        let c = l.length;
+        if (i + 1 < r.length) for (let h = r[i + 1]; i + 1 < r.length && h.deleted; h = r[++i + 1]) c += h.length;
+        s.push(new re(o, c));
+      }
+    }
+    s.length > 0 && t.clients.set(n, s);
+  }), t;
+}, dt = (e, t) => {
+  v(e.restEncoder, t.clients.size), Y(t.clients.entries()).sort((r, n) => n[0] - r[0]).forEach(([r, n]) => {
+    e.resetDsCurVal(), v(e.restEncoder, r);
+    const s = n.length;
+    v(e.restEncoder, s);
+    for (let i = 0; i < s; i++) {
+      const l = n[i];
+      e.writeDsClock(l.clock), e.writeDsLen(l.len);
+    }
+  });
+}, Qe = (e) => {
+  const t = new Et(), r = p(e.restDecoder);
+  for (let n = 0; n < r; n++) {
+    e.resetDsCurVal();
+    const s = p(e.restDecoder), i = p(e.restDecoder);
+    if (i > 0) {
+      const l = J(t.clients, s, () => []);
+      for (let o = 0; o < i; o++) l.push(new re(e.readDsClock(), e.readDsLen()));
+    }
+  }
+  return t;
+}, Dr = (e, t, r) => {
+  const n = new Et(), s = p(e.restDecoder);
+  for (let i = 0; i < s; i++) {
+    e.resetDsCurVal();
+    const l = p(e.restDecoder), o = p(e.restDecoder), c = r.clients.get(l) || [], h = b(r, l);
+    for (let a = 0; a < o; a++) {
+      const d = e.readDsClock(), u = d + e.readDsLen();
+      if (d < h) {
+        h < u && jt(n, l, h, u - h);
+        let f = F(c, d), g = c[f];
+        for (!g.deleted && g.id.clock < d && (c.splice(f + 1, 0, Ht(t, g, d - g.id.clock)), f++); f < c.length && (g = c[f++], g.id.clock < u); )
+          g.deleted || (u < g.id.clock + g.length && c.splice(f, 0, Ht(t, g, u - g.id.clock)), g.delete(t));
+      } else jt(n, l, d, u - d);
+    }
+  }
+  if (n.clients.size > 0) {
+    const i = new W();
+    return v(i.restEncoder, 0), dt(i, n), i.toUint8Array();
+  }
+  return null;
+}, On = jr, Pe = class xn extends bs {
+  constructor({ guid: t = Vs(), collectionid: r = null, gc: n = !0, gcFilter: s = () => !0, meta: i = null, autoLoad: l = !1, shouldLoad: o = !0 } = {}) {
+    super(), this.gc = n, this.gcFilter = s, this.clientID = On(), this.guid = t, this.collectionid = r, this.share = /* @__PURE__ */ new Map(), this.store = new Fn(), this._transaction = null, this._transactionCleanups = [], this.subdocs = /* @__PURE__ */ new Set(), this._item = null, this.shouldLoad = o, this.autoLoad = l, this.meta = i, this.isLoaded = !1, this.isSynced = !1, this.isDestroyed = !1, this.whenLoaded = Er((h) => {
+      this.on("load", () => {
+        this.isLoaded = !0, h(this);
+      });
+    });
+    const c = () => Er((h) => {
+      const a = (d) => {
+        (d === void 0 || d === !0) && (this.off("sync", a), h());
+      };
+      this.on("sync", a);
+    });
+    this.on("sync", (h) => {
+      h === !1 && this.isSynced && (this.whenSynced = c()), this.isSynced = h === void 0 || h === !0, this.isSynced && !this.isLoaded && this.emit("load", [this]);
+    }), this.whenSynced = c();
+  }
+  load() {
+    const t = this._item;
+    t !== null && !this.shouldLoad && m(t.parent.doc, (r) => {
+      r.subdocsLoaded.add(this);
+    }, null, !0), this.shouldLoad = !0;
+  }
+  getSubdocs() {
+    return this.subdocs;
+  }
+  getSubdocGuids() {
+    return new Set(Y(this.subdocs).map((t) => t.guid));
+  }
+  transact(t, r = null) {
+    return m(this, t, r);
+  }
+  get(t, r = C) {
+    const n = J(this.share, t, () => {
+      const i = new r();
+      return i._integrate(this, null), i;
+    }), s = n.constructor;
+    if (r !== C && s !== r) if (s === C) {
+      const i = new r();
+      i._map = n._map, n._map.forEach((l) => {
+        for (; l !== null; l = l.left) l.parent = i;
+      }), i._start = n._start;
+      for (let l = i._start; l !== null; l = l.right) l.parent = i;
+      return i._length = n._length, this.share.set(t, i), i._integrate(this, null), i;
+    } else throw new Error(`Type with the name ${t} has already been defined with a different constructor`);
+    return n;
+  }
+  getArray(t = "") {
+    return this.get(t, rs);
+  }
+  getText(t = "") {
+    return this.get(t, cr);
+  }
+  getMap(t = "") {
+    return this.get(t, or);
+  }
+  getXmlElement(t = "") {
+    return this.get(t, ar);
+  }
+  getXmlFragment(t = "") {
+    return this.get(t, oe);
+  }
+  toJSON() {
+    const t = {};
+    return this.share.forEach((r, n) => {
+      t[n] = r.toJSON();
+    }), t;
+  }
+  destroy() {
+    this.isDestroyed = !0, Y(this.subdocs).forEach((r) => r.destroy());
+    const t = this._item;
+    if (t !== null) {
+      this._item = null;
+      const r = t.content;
+      r.doc = new xn({
+        guid: this.guid,
+        ...r.opts,
+        shouldLoad: !1
+      }), r.doc._item = t, m(t.parent.doc, (n) => {
+        const s = r.doc;
+        t.deleted || n.subdocsAdded.add(s), n.subdocsRemoved.add(this);
+      }, null, !0);
+    }
+    this.emit("destroyed", [!0]), this.emit("destroy", [this]), super.destroy();
+  }
+}, Ln = class {
+  constructor(e) {
+    this.restDecoder = e;
+  }
+  resetDsCurVal() {
+  }
+  readDsClock() {
+    return p(this.restDecoder);
+  }
+  readDsLen() {
+    return p(this.restDecoder);
+  }
+}, $n = class extends Ln {
+  readLeftID() {
+    return w(p(this.restDecoder), p(this.restDecoder));
+  }
+  readRightID() {
+    return w(p(this.restDecoder), p(this.restDecoder));
+  }
+  readClient() {
+    return p(this.restDecoder);
+  }
+  readInfo() {
+    return lt(this.restDecoder);
+  }
+  readString() {
+    return nt(this.restDecoder);
+  }
+  readParentInfo() {
+    return p(this.restDecoder) === 1;
+  }
+  readTypeRef() {
+    return p(this.restDecoder);
+  }
+  readLen() {
+    return p(this.restDecoder);
+  }
+  readAny() {
+    return wt(this.restDecoder);
+  }
+  readBuf() {
+    return Ri(x(this.restDecoder));
+  }
+  readJSON() {
+    return JSON.parse(nt(this.restDecoder));
+  }
+  readKey() {
+    return nt(this.restDecoder);
+  }
+}, Il = class {
+  constructor(e) {
+    this.dsCurrVal = 0, this.restDecoder = e;
+  }
+  resetDsCurVal() {
+    this.dsCurrVal = 0;
+  }
+  readDsClock() {
+    return this.dsCurrVal += p(this.restDecoder), this.dsCurrVal;
+  }
+  readDsLen() {
+    const e = p(this.restDecoder) + 1;
+    return this.dsCurrVal += e, e;
+  }
+}, at = class extends Il {
+  constructor(e) {
+    super(e), this.keys = [], p(e), this.keyClockDecoder = new he(x(e)), this.clientDecoder = new $t(x(e)), this.leftClockDecoder = new he(x(e)), this.rightClockDecoder = new he(x(e)), this.infoDecoder = new yr(x(e), lt), this.stringDecoder = new fi(x(e)), this.parentInfoDecoder = new yr(x(e), lt), this.typeRefDecoder = new $t(x(e)), this.lenDecoder = new $t(x(e));
+  }
+  readLeftID() {
+    return new it(this.clientDecoder.read(), this.leftClockDecoder.read());
+  }
+  readRightID() {
+    return new it(this.clientDecoder.read(), this.rightClockDecoder.read());
+  }
+  readClient() {
+    return this.clientDecoder.read();
+  }
+  readInfo() {
+    return this.infoDecoder.read();
+  }
+  readString() {
+    return this.stringDecoder.read();
+  }
+  readParentInfo() {
+    return this.parentInfoDecoder.read() === 1;
+  }
+  readTypeRef() {
+    return this.typeRefDecoder.read();
+  }
+  readLen() {
+    return this.lenDecoder.read();
+  }
+  readAny() {
+    return wt(this.restDecoder);
+  }
+  readBuf() {
+    return x(this.restDecoder);
+  }
+  readJSON() {
+    return wt(this.restDecoder);
+  }
+  readKey() {
+    const e = this.keyClockDecoder.read();
+    if (e < this.keys.length) return this.keys[e];
+    {
+      const t = this.stringDecoder.read();
+      return this.keys.push(t), t;
+    }
+  }
+}, Nn = class {
+  constructor() {
+    this.restEncoder = Kt();
+  }
+  toUint8Array() {
+    return R(this.restEncoder);
+  }
+  resetDsCurVal() {
+  }
+  writeDsClock(e) {
+    v(this.restEncoder, e);
+  }
+  writeDsLen(e) {
+    v(this.restEncoder, e);
+  }
+}, Dt = class extends Nn {
+  writeLeftID(e) {
+    v(this.restEncoder, e.client), v(this.restEncoder, e.clock);
+  }
+  writeRightID(e) {
+    v(this.restEncoder, e.client), v(this.restEncoder, e.clock);
+  }
+  writeClient(e) {
+    v(this.restEncoder, e);
+  }
+  writeInfo(e) {
+    ye(this.restEncoder, e);
+  }
+  writeString(e) {
+    rt(this.restEncoder, e);
+  }
+  writeParentInfo(e) {
+    v(this.restEncoder, e ? 1 : 0);
+  }
+  writeTypeRef(e) {
+    v(this.restEncoder, e);
+  }
+  writeLen(e) {
+    v(this.restEncoder, e);
+  }
+  writeAny(e) {
+    vt(this.restEncoder, e);
+  }
+  writeBuf(e) {
+    O(this.restEncoder, e);
+  }
+  writeJSON(e) {
+    rt(this.restEncoder, JSON.stringify(e));
+  }
+  writeKey(e) {
+    rt(this.restEncoder, e);
+  }
+}, Mn = class {
+  constructor() {
+    this.restEncoder = Kt(), this.dsCurrVal = 0;
+  }
+  toUint8Array() {
+    return R(this.restEncoder);
+  }
+  resetDsCurVal() {
+    this.dsCurrVal = 0;
+  }
+  writeDsClock(e) {
+    const t = e - this.dsCurrVal;
+    this.dsCurrVal = e, v(this.restEncoder, t);
+  }
+  writeDsLen(e) {
+    e === 0 && N(), v(this.restEncoder, e - 1), this.dsCurrVal += e;
+  }
+}, W = class extends Mn {
+  constructor() {
+    super(), this.keyMap = /* @__PURE__ */ new Map(), this.keyClock = 0, this.keyClockEncoder = new ae(), this.clientEncoder = new Lt(), this.leftClockEncoder = new ae(), this.rightClockEncoder = new ae(), this.infoEncoder = new vr(ye), this.stringEncoder = new si(), this.parentInfoEncoder = new vr(ye), this.typeRefEncoder = new Lt(), this.lenEncoder = new Lt();
+  }
+  toUint8Array() {
+    const e = Kt();
+    return v(e, 0), O(e, this.keyClockEncoder.toUint8Array()), O(e, this.clientEncoder.toUint8Array()), O(e, this.leftClockEncoder.toUint8Array()), O(e, this.rightClockEncoder.toUint8Array()), O(e, R(this.infoEncoder)), O(e, this.stringEncoder.toUint8Array()), O(e, R(this.parentInfoEncoder)), O(e, this.typeRefEncoder.toUint8Array()), O(e, this.lenEncoder.toUint8Array()), Wt(e, R(this.restEncoder)), R(e);
+  }
+  writeLeftID(e) {
+    this.clientEncoder.write(e.client), this.leftClockEncoder.write(e.clock);
+  }
+  writeRightID(e) {
+    this.clientEncoder.write(e.client), this.rightClockEncoder.write(e.clock);
+  }
+  writeClient(e) {
+    this.clientEncoder.write(e);
+  }
+  writeInfo(e) {
+    this.infoEncoder.write(e);
+  }
+  writeString(e) {
+    this.stringEncoder.write(e);
+  }
+  writeParentInfo(e) {
+    this.parentInfoEncoder.write(e ? 1 : 0);
+  }
+  writeTypeRef(e) {
+    this.typeRefEncoder.write(e);
+  }
+  writeLen(e) {
+    this.lenEncoder.write(e);
+  }
+  writeAny(e) {
+    vt(this.restEncoder, e);
+  }
+  writeBuf(e) {
+    O(this.restEncoder, e);
+  }
+  writeJSON(e) {
+    vt(this.restEncoder, e);
+  }
+  writeKey(e) {
+    const t = this.keyMap.get(e);
+    t === void 0 ? (this.keyClockEncoder.write(this.keyClock++), this.stringEncoder.write(e)) : this.keyClockEncoder.write(t);
+  }
+}, Tl = (e, t, r, n) => {
+  n = Z(n, t[0].id.clock);
+  const s = F(t, n);
+  v(e.restEncoder, t.length - s), e.writeClient(r), v(e.restEncoder, n);
+  const i = t[s];
+  i.write(e, n - i.id.clock);
+  for (let l = s + 1; l < t.length; l++) t[l].write(e, 0);
+}, tr = (e, t, r) => {
+  const n = /* @__PURE__ */ new Map();
+  r.forEach((s, i) => {
+    b(t, i) > s && n.set(i, s);
+  }), ne(t).forEach((s, i) => {
+    r.has(i) || n.set(i, 0);
+  }), v(e.restEncoder, n.size), Y(n.entries()).sort((s, i) => i[0] - s[0]).forEach(([s, i]) => {
+    Tl(e, t.clients.get(s), s, i);
+  });
+}, Ol = (e, t) => {
+  const r = T(), n = p(e.restDecoder);
+  for (let s = 0; s < n; s++) {
+    const i = p(e.restDecoder), l = new Array(i), o = e.readClient();
+    let c = p(e.restDecoder);
+    r.set(o, {
+      i: 0,
+      refs: l
+    });
+    for (let h = 0; h < i; h++) {
+      const a = e.readInfo();
+      switch (31 & a) {
+        case 0: {
+          const d = e.readLen();
+          l[h] = new L(w(o, c), d), c += d;
+          break;
+        }
+        case 10: {
+          const d = p(e.restDecoder);
+          l[h] = new $(w(o, c), d), c += d;
+          break;
+        }
+        default: {
+          const d = (a & 192) === 0, u = new D(w(o, c), null, (a & 128) === 128 ? e.readLeftID() : null, null, (a & 64) === 64 ? e.readRightID() : null, d ? e.readParentInfo() ? t.get(e.readString()) : e.readLeftID() : null, d && (a & 32) === 32 ? e.readString() : null, gs(e, a));
+          l[h] = u, c += u.length;
+        }
+      }
+    }
+  }
+  return r;
+}, xl = (e, t, r) => {
+  const n = [];
+  let s = Y(r.keys()).sort((f, g) => f - g);
+  if (s.length === 0) return null;
+  const i = () => {
+    if (s.length === 0) return null;
+    let f = r.get(s[s.length - 1]);
+    for (; f.refs.length === f.i; )
+      if (s.pop(), s.length > 0) f = r.get(s[s.length - 1]);
+      else return null;
+    return f;
+  };
+  let l = i();
+  if (l === null) return null;
+  const o = new Fn(), c = /* @__PURE__ */ new Map(), h = (f, g) => {
+    const y = c.get(f);
+    (y == null || y > g) && c.set(f, g);
+  };
+  let a = l.refs[l.i++];
+  const d = /* @__PURE__ */ new Map(), u = () => {
+    for (const f of n) {
+      const g = f.id.client, y = r.get(g);
+      y ? (y.i--, o.clients.set(g, y.refs.slice(y.i)), r.delete(g), y.i = 0, y.refs = []) : o.clients.set(g, [f]), s = s.filter((ws) => ws !== g);
+    }
+    n.length = 0;
+  };
+  for (; ; ) {
+    if (a.constructor !== $) {
+      const f = J(d, a.id.client, () => b(t, a.id.client)) - a.id.clock;
+      if (f < 0)
+        n.push(a), h(a.id.client, a.id.clock - 1), u();
+      else {
+        const g = a.getMissing(e, t);
+        if (g !== null) {
+          n.push(a);
+          const y = r.get(g) || {
+            refs: [],
+            i: 0
+          };
+          if (y.refs.length === y.i)
+            h(g, b(t, g)), u();
+          else {
+            a = y.refs[y.i++];
+            continue;
+          }
+        } else (f === 0 || f < a.length) && (a.integrate(e, f), d.set(a.id.client, a.id.clock + a.length));
+      }
+    }
+    if (n.length > 0) a = n.pop();
+    else if (l !== null && l.i < l.refs.length) a = l.refs[l.i++];
+    else {
+      if (l = i(), l === null) break;
+      a = l.refs[l.i++];
+    }
+  }
+  if (o.clients.size > 0) {
+    const f = new W();
+    return tr(f, o, /* @__PURE__ */ new Map()), v(f.restEncoder, 0), {
+      missing: c,
+      update: f.toUint8Array()
+    };
+  }
+  return null;
+}, Ll = (e, t) => tr(e, t.doc.store, t.beforeState), $l = (e, t, r, n = new at(e)) => m(t, (s) => {
+  s.local = !1;
+  let i = !1;
+  const l = s.doc, o = l.store, c = Ol(n, l), h = xl(s, o, c), a = o.pendingStructs;
+  if (a) {
+    for (const [u, f] of a.missing) if (f < b(o, u)) {
+      i = !0;
+      break;
+    }
+    if (h) {
+      for (const [u, f] of h.missing) {
+        const g = a.missing.get(u);
+        (g == null || g > f) && a.missing.set(u, f);
+      }
+      a.update = Yt([a.update, h.update]);
+    }
+  } else o.pendingStructs = h;
+  const d = Dr(n, s, o);
+  if (o.pendingDs) {
+    const u = new at(ht(o.pendingDs));
+    p(u.restDecoder);
+    const f = Dr(u, s, o);
+    d && f ? o.pendingDs = Yt([d, f]) : o.pendingDs = d || f;
+  } else o.pendingDs = d;
+  if (i) {
+    const u = o.pendingStructs.update;
+    o.pendingStructs = null, Un(s.doc, u);
+  }
+}, r, !1), Un = (e, t, r, n = at) => {
+  const s = ht(t);
+  $l(s, e, r, new n(s));
+}, Wc = (e, t, r) => Un(e, t, r, $n), Nl = (e, t, r = /* @__PURE__ */ new Map()) => {
+  tr(e, t.store, r), dt(e, Al(t.store));
+}, Ml = (e, t = new Uint8Array([0]), r = new W()) => {
+  const n = Rn(t);
+  Nl(r, e, n);
+  const s = [r.toUint8Array()];
+  if (e.store.pendingDs && s.push(e.store.pendingDs), e.store.pendingStructs && s.push(Zl(e.store.pendingStructs.update, t)), s.length > 1) {
+    if (r.constructor === Dt) return Wl(s.map((i, l) => l === 0 ? i : Pl(i)));
+    if (r.constructor === W) return Yt(s);
+  }
+  return s[0];
+}, qc = (e, t) => Ml(e, t, new Dt()), Ul = (e) => {
+  const t = /* @__PURE__ */ new Map(), r = p(e.restDecoder);
+  for (let n = 0; n < r; n++) {
+    const s = p(e.restDecoder), i = p(e.restDecoder);
+    t.set(s, i);
+  }
+  return t;
+}, Rn = (e) => Ul(new Ln(ht(e))), Bn = (e, t) => (v(e.restEncoder, t.size), Y(t.entries()).sort((r, n) => n[0] - r[0]).forEach(([r, n]) => {
+  v(e.restEncoder, r), v(e.restEncoder, n);
+}), e), Rl = (e, t) => Bn(e, ne(t.store)), Bl = (e, t = new Mn()) => (e instanceof Map ? Bn(t, e) : Rl(t, e), t.toUint8Array()), Zc = (e) => Bl(e, new Nn()), Vl = class {
+  constructor() {
+    this.l = [];
+  }
+}, Ar = () => new Vl(), Ir = (e, t) => e.l.push(t), Tr = (e, t) => {
+  const r = e.l, n = r.length;
+  e.l = r.filter((s) => t !== s), n === e.l.length && console.error("[yjs] Tried to remove event handler that doesn't exist.");
+}, Vn = (e, t, r) => Ge(e.l, [t, r]), it = class {
+  constructor(e, t) {
+    this.client = e, this.clock = t;
+  }
+}, It = (e, t) => e === t || e !== null && t !== null && e.client === t.client && e.clock === t.clock, w = (e, t) => new it(e, t), Fl = (e) => {
+  for (const [t, r] of e.doc.share.entries()) if (r === e) return t;
+  throw N();
+}, jl = class {
+  constructor(e, t) {
+    this.ds = e, this.sv = t;
+  }
+}, Yl = (e, t) => new jl(e, t), Qc = Yl(Tn(), /* @__PURE__ */ new Map()), et = (e, t) => t === void 0 ? !e.deleted : t.sv.has(e.id.client) && (t.sv.get(e.id.client) || 0) > e.id.clock && !In(t.ds, e.id), Se = (e, t) => {
+  const r = J(e.meta, Se, K), n = e.doc.store;
+  r.has(t) || (t.sv.forEach((s, i) => {
+    s < b(n, i) && z(e, w(i, s));
+  }), An(e, t.ds, (s) => {
+  }), r.add(t));
+}, Fn = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map(), this.pendingStructs = null, this.pendingDs = null;
+  }
+}, ne = (e) => {
+  const t = /* @__PURE__ */ new Map();
+  return e.clients.forEach((r, n) => {
+    const s = r[r.length - 1];
+    t.set(n, s.id.clock + s.length);
+  }), t;
+}, b = (e, t) => {
+  const r = e.clients.get(t);
+  if (r === void 0) return 0;
+  const n = r[r.length - 1];
+  return n.id.clock + n.length;
+}, jn = (e, t) => {
+  let r = e.clients.get(t.id.client);
+  if (r === void 0)
+    r = [], e.clients.set(t.id.client, r);
+  else {
+    const n = r[r.length - 1];
+    if (n.id.clock + n.length !== t.id.clock) throw N();
+  }
+  r.push(t);
+}, F = (e, t) => {
+  let r = 0, n = e.length - 1, s = e[n], i = s.id.clock;
+  if (i === t) return n;
+  let l = B(t / (i + s.length - 1) * n);
+  for (; r <= n; ) {
+    if (s = e[l], i = s.id.clock, i <= t) {
+      if (t < i + s.length) return l;
+      r = l + 1;
+    } else n = l - 1;
+    l = B((r + n) / 2);
+  }
+  throw N();
+}, Jl = (e, t) => {
+  const r = e.clients.get(t.client);
+  return r[F(r, t.clock)];
+}, pe = Jl, Ce = (e, t, r) => {
+  const n = F(t, r), s = t[n];
+  return s.id.clock < r && s instanceof D ? (t.splice(n + 1, 0, Ht(e, s, r - s.id.clock)), n + 1) : n;
+}, z = (e, t) => {
+  const r = e.doc.store.clients.get(t.client);
+  return r[Ce(e, r, t.clock)];
+}, Or = (e, t, r) => {
+  const n = t.clients.get(r.client), s = F(n, r.clock), i = n[s];
+  return r.clock !== i.id.clock + i.length - 1 && i.constructor !== L && n.splice(s + 1, 0, Ht(e, i, r.clock - i.id.clock + 1)), i;
+}, Xl = (e, t, r) => {
+  const n = e.clients.get(t.id.client);
+  n[F(n, t.id.clock)] = r;
+}, Yn = (e, t, r, n, s) => {
+  if (n === 0) return;
+  const i = r + n;
+  let l = Ce(e, t, r), o;
+  do
+    o = t[l++], i < o.id.clock + o.length && Ce(e, t, i), s(o);
+  while (l < t.length && t[l].id.clock < i);
+}, Gl = class {
+  constructor(e, t, r) {
+    this.doc = e, this.deleteSet = new Et(), this.beforeState = ne(e.store), this.afterState = /* @__PURE__ */ new Map(), this.changed = /* @__PURE__ */ new Map(), this.changedParentTypes = /* @__PURE__ */ new Map(), this._mergeStructs = [], this.origin = t, this.meta = /* @__PURE__ */ new Map(), this.local = r, this.subdocsAdded = /* @__PURE__ */ new Set(), this.subdocsRemoved = /* @__PURE__ */ new Set(), this.subdocsLoaded = /* @__PURE__ */ new Set(), this._needFormattingCleanup = !1;
+  }
+}, xr = (e, t) => t.deleteSet.clients.size === 0 && !ys(t.afterState, (r, n) => t.beforeState.get(n) !== r) ? !1 : (Ze(t.deleteSet), Ll(e, t), dt(e, t.deleteSet), !0), Lr = (e, t, r) => {
+  const n = t._item;
+  (n === null || n.id.clock < (e.beforeState.get(n.id.client) || 0) && !n.deleted) && J(e.changed, t, K).add(r);
+}, Mt = (e, t) => {
+  let r = e[t], n = e[t - 1], s = t;
+  for (; s > 0; r = n, n = e[--s - 1]) {
+    if (n.deleted === r.deleted && n.constructor === r.constructor && n.mergeWith(r)) {
+      r instanceof D && r.parentSub !== null && r.parent._map.get(r.parentSub) === r && r.parent._map.set(r.parentSub, n);
+      continue;
+    }
+    break;
+  }
+  const i = t - s;
+  return i && e.splice(t + 1 - i, i), i;
+}, Hl = (e, t, r) => {
+  for (const [n, s] of e.clients.entries()) {
+    const i = t.clients.get(n);
+    for (let l = s.length - 1; l >= 0; l--) {
+      const o = s[l], c = o.clock + o.len;
+      for (let h = F(i, o.clock), a = i[h]; h < i.length && a.id.clock < c; a = i[++h]) {
+        const d = i[h];
+        if (o.clock + o.len <= d.id.clock) break;
+        d instanceof D && d.deleted && !d.keep && r(d) && d.gc(t, !1);
+      }
+    }
+  }
+}, zl = (e, t) => {
+  e.clients.forEach((r, n) => {
+    const s = t.clients.get(n);
+    for (let i = r.length - 1; i >= 0; i--) {
+      const l = r[i], o = Br(s.length - 1, 1 + F(s, l.clock + l.len - 1));
+      for (let c = o, h = s[c]; c > 0 && h.id.clock >= l.clock; h = s[c]) c -= 1 + Mt(s, c);
+    }
+  });
+}, Jn = (e, t) => {
+  if (t < e.length) {
+    const r = e[t], n = r.doc, s = n.store, i = r.deleteSet, l = r._mergeStructs;
+    try {
+      Ze(i), r.afterState = ne(r.doc.store), n.emit("beforeObserverCalls", [r, n]);
+      const o = [];
+      r.changed.forEach((c, h) => o.push(() => {
+        (h._item === null || !h._item.deleted) && h._callObserver(r, c);
+      })), o.push(() => {
+        r.changedParentTypes.forEach((c, h) => {
+          h._dEH.l.length > 0 && (h._item === null || !h._item.deleted) && (c = c.filter((a) => a.target._item === null || !a.target._item.deleted), c.forEach((a) => {
+            a.currentTarget = h, a._path = null;
+          }), c.sort((a, d) => a.path.length - d.path.length), o.push(() => {
+            Vn(h._dEH, c, r);
+          }));
+        }), o.push(() => n.emit("afterTransaction", [r, n])), o.push(() => {
+          r._needFormattingCleanup && go(r);
+        });
+      }), Ge(o, []);
+    } finally {
+      n.gc && Hl(i, s, n.gcFilter), zl(i, s), r.afterState.forEach((a, d) => {
+        const u = r.beforeState.get(d) || 0;
+        if (u !== a) {
+          const f = s.clients.get(d), g = Z(F(f, u), 1);
+          for (let y = f.length - 1; y >= g; ) y -= 1 + Mt(f, y);
+        }
+      });
+      for (let a = l.length - 1; a >= 0; a--) {
+        const { client: d, clock: u } = l[a].id, f = s.clients.get(d), g = F(f, u);
+        g + 1 < f.length && Mt(f, g + 1) > 1 || g > 0 && Mt(f, g);
+      }
+      if (!r.local && r.afterState.get(n.clientID) !== r.beforeState.get(n.clientID) && (Cn(ee, vn, "[yjs] ", wn, kn, "Changed the client-id because another client seems to be using it."), n.clientID = On()), n.emit("afterTransactionCleanup", [r, n]), n._observers.has("update")) {
+        const a = new Dt();
+        xr(a, r) && n.emit("update", [
+          a.toUint8Array(),
+          r.origin,
+          n,
+          r
+        ]);
+      }
+      if (n._observers.has("updateV2")) {
+        const a = new W();
+        xr(a, r) && n.emit("updateV2", [
+          a.toUint8Array(),
+          r.origin,
+          n,
+          r
+        ]);
+      }
+      const { subdocsAdded: o, subdocsLoaded: c, subdocsRemoved: h } = r;
+      (o.size > 0 || h.size > 0 || c.size > 0) && (o.forEach((a) => {
+        a.clientID = n.clientID, a.collectionid == null && (a.collectionid = n.collectionid), n.subdocs.add(a);
+      }), h.forEach((a) => n.subdocs.delete(a)), n.emit("subdocs", [
+        {
+          loaded: c,
+          added: o,
+          removed: h
+        },
+        n,
+        r
+      ]), h.forEach((a) => a.destroy())), e.length <= t + 1 ? (n._transactionCleanups = [], n.emit("afterAllTransactions", [n, e])) : Jn(e, t + 1);
+    }
+  }
+}, m = (e, t, r = null, n = !0) => {
+  const s = e._transactionCleanups;
+  let i = !1, l = null;
+  e._transaction === null && (i = !0, e._transaction = new Gl(e, r, n), s.push(e._transaction), s.length === 1 && e.emit("beforeAllTransactions", [e]), e.emit("beforeTransaction", [e._transaction, e]));
+  try {
+    l = t(e._transaction);
+  } finally {
+    if (i) {
+      const o = e._transaction === s[0];
+      e._transaction = null, o && Jn(s, 0);
+    }
+  }
+  return l;
+};
+function* Kl(e) {
+  const t = p(e.restDecoder);
+  for (let r = 0; r < t; r++) {
+    const n = p(e.restDecoder), s = e.readClient();
+    let i = p(e.restDecoder);
+    for (let l = 0; l < n; l++) {
+      const o = e.readInfo();
+      if (o === 10) {
+        const c = p(e.restDecoder);
+        yield new $(w(s, i), c), i += c;
+      } else if ((31 & o) !== 0) {
+        const c = (o & 192) === 0, h = new D(w(s, i), null, (o & 128) === 128 ? e.readLeftID() : null, null, (o & 64) === 64 ? e.readRightID() : null, c ? e.readParentInfo() ? e.readString() : e.readLeftID() : null, c && (o & 32) === 32 ? e.readString() : null, gs(e, o));
+        yield h, i += h.length;
+      } else {
+        const c = e.readLen();
+        yield new L(w(s, i), c), i += c;
+      }
+    }
+  }
+}
+var er = class {
+  constructor(e, t) {
+    this.gen = Kl(e), this.curr = null, this.done = !1, this.filterSkips = t, this.next();
+  }
+  next() {
+    do
+      this.curr = this.gen.next().value || null;
+    while (this.filterSkips && this.curr !== null && this.curr.constructor === $);
+    return this.curr;
+  }
+}, rr = class {
+  constructor(e) {
+    this.currClient = 0, this.startClock = 0, this.written = 0, this.encoder = e, this.clientStructs = [];
+  }
+}, Wl = (e) => Yt(e, $n, Dt), ql = (e, t) => {
+  if (e.constructor === L) {
+    const { client: r, clock: n } = e.id;
+    return new L(w(r, n + t), e.length - t);
+  } else if (e.constructor === $) {
+    const { client: r, clock: n } = e.id;
+    return new $(w(r, n + t), e.length - t);
+  } else {
+    const r = e, { client: n, clock: s } = r.id;
+    return new D(w(n, s + t), null, w(n, s + t - 1), null, r.rightOrigin, r.parent, r.parentSub, r.content.splice(t));
+  }
+}, Yt = (e, t = at, r = W) => {
+  if (e.length === 1) return e[0];
+  const n = e.map((a) => new t(ht(a)));
+  let s = n.map((a) => new er(a, !0)), i = null;
+  const l = new r(), o = new rr(l);
+  for (; s = s.filter((u) => u.curr !== null), s.sort((u, f) => {
+    if (u.curr.id.client === f.curr.id.client) {
+      const g = u.curr.id.clock - f.curr.id.clock;
+      return g === 0 ? u.curr.constructor === f.curr.constructor ? 0 : u.curr.constructor === $ ? 1 : -1 : g;
+    } else return f.curr.id.client - u.curr.id.client;
+  }), s.length !== 0; ) {
+    const a = s[0], d = a.curr.id.client;
+    if (i !== null) {
+      let u = a.curr, f = !1;
+      for (; u !== null && u.id.clock + u.length <= i.struct.id.clock + i.struct.length && u.id.client >= i.struct.id.client; )
+        u = a.next(), f = !0;
+      if (u === null || u.id.client !== d || f && u.id.clock > i.struct.id.clock + i.struct.length) continue;
+      if (d !== i.struct.id.client)
+        G(o, i.struct, i.offset), i = {
+          struct: u,
+          offset: 0
+        }, a.next();
+      else if (i.struct.id.clock + i.struct.length < u.id.clock) if (i.struct.constructor === $) i.struct.length = u.id.clock + u.length - i.struct.id.clock;
+      else {
+        G(o, i.struct, i.offset);
+        const g = u.id.clock - i.struct.id.clock - i.struct.length;
+        i = {
+          struct: new $(w(d, i.struct.id.clock + i.struct.length), g),
+          offset: 0
+        };
+      }
+      else {
+        const g = i.struct.id.clock + i.struct.length - u.id.clock;
+        g > 0 && (i.struct.constructor === $ ? i.struct.length -= g : u = ql(u, g)), i.struct.mergeWith(u) || (G(o, i.struct, i.offset), i = {
+          struct: u,
+          offset: 0
+        }, a.next());
+      }
+    } else
+      i = {
+        struct: a.curr,
+        offset: 0
+      }, a.next();
+    for (let u = a.curr; u !== null && u.id.client === d && u.id.clock === i.struct.id.clock + i.struct.length && u.constructor !== $; u = a.next())
+      G(o, i.struct, i.offset), i = {
+        struct: u,
+        offset: 0
+      };
+  }
+  i !== null && (G(o, i.struct, i.offset), i = null), nr(o);
+  const c = n.map((a) => Qe(a)), h = Dl(c);
+  return dt(l, h), l.toUint8Array();
+}, Zl = (e, t, r = at, n = W) => {
+  const s = Rn(t), i = new n(), l = new rr(i), o = new r(ht(e)), c = new er(o, !1);
+  for (; c.curr; ) {
+    const a = c.curr, d = a.id.client, u = s.get(d) || 0;
+    if (c.curr.constructor === $) {
+      c.next();
+      continue;
+    }
+    if (a.id.clock + a.length > u)
+      for (G(l, a, Z(u - a.id.clock, 0)), c.next(); c.curr && c.curr.id.client === d; )
+        G(l, c.curr, 0), c.next();
+    else for (; c.curr && c.curr.id.client === d && c.curr.id.clock + c.curr.length <= u; ) c.next();
+  }
+  nr(l);
+  const h = Qe(o);
+  return dt(i, h), i.toUint8Array();
+}, Xn = (e) => {
+  e.written > 0 && (e.clientStructs.push({
+    written: e.written,
+    restEncoder: R(e.encoder.restEncoder)
+  }), e.encoder.restEncoder = Kt(), e.written = 0);
+}, G = (e, t, r) => {
+  e.written > 0 && e.currClient !== t.id.client && Xn(e), e.written === 0 && (e.currClient = t.id.client, e.encoder.writeClient(t.id.client), v(e.encoder.restEncoder, t.id.clock + r)), t.write(e.encoder, r), e.written++;
+}, nr = (e) => {
+  Xn(e);
+  const t = e.encoder.restEncoder;
+  v(t, e.clientStructs.length);
+  for (let r = 0; r < e.clientStructs.length; r++) {
+    const n = e.clientStructs[r];
+    v(t, n.written), Wt(t, n.restEncoder);
+  }
+}, Ql = (e, t, r, n) => {
+  const s = new r(ht(e)), i = new er(s, !1), l = new n(), o = new rr(l);
+  for (let h = i.curr; h !== null; h = i.next()) G(o, t(h), 0);
+  nr(o);
+  const c = Qe(s);
+  return dt(l, c), l.toUint8Array();
+}, Pl = (e) => Ql(e, Ci, at, Dt), $r = "You must not compute changes after the event-handler fired.", se = class {
+  constructor(e, t) {
+    this.target = e, this.currentTarget = e, this.transaction = t, this._changes = null, this._keys = null, this._delta = null, this._path = null;
+  }
+  get path() {
+    return this._path || (this._path = to(this.currentTarget, this.target));
+  }
+  deletes(e) {
+    return In(this.transaction.deleteSet, e.id);
+  }
+  get keys() {
+    if (this._keys === null) {
+      if (this.transaction.doc._transactionCleanups.length === 0) throw V($r);
+      const e = /* @__PURE__ */ new Map(), t = this.target;
+      this.transaction.changed.get(t).forEach((r) => {
+        if (r !== null) {
+          const n = t._map.get(r);
+          let s, i;
+          if (this.adds(n)) {
+            let l = n.left;
+            for (; l !== null && this.adds(l); ) l = l.left;
+            if (this.deletes(n)) if (l !== null && this.deletes(l))
+              s = "delete", i = ce(l.content.getContent());
+            else return;
+            else l !== null && this.deletes(l) ? (s = "update", i = ce(l.content.getContent())) : (s = "add", i = void 0);
+          } else if (this.deletes(n))
+            s = "delete", i = ce(n.content.getContent());
+          else return;
+          e.set(r, {
+            action: s,
+            oldValue: i
+          });
+        }
+      }), this._keys = e;
+    }
+    return this._keys;
+  }
+  get delta() {
+    return this.changes.delta;
+  }
+  adds(e) {
+    return e.id.clock >= (this.transaction.beforeState.get(e.id.client) || 0);
+  }
+  get changes() {
+    let e = this._changes;
+    if (e === null) {
+      if (this.transaction.doc._transactionCleanups.length === 0) throw V($r);
+      const t = this.target, r = K(), n = K(), s = [];
+      if (e = {
+        added: r,
+        deleted: n,
+        delta: s,
+        keys: this.keys
+      }, this.transaction.changed.get(t).has(null)) {
+        let i = null;
+        const l = () => {
+          i && s.push(i);
+        };
+        for (let o = t._start; o !== null; o = o.right) o.deleted ? this.deletes(o) && !this.adds(o) && ((i === null || i.delete === void 0) && (l(), i = { delete: 0 }), i.delete += o.length, n.add(o)) : this.adds(o) ? ((i === null || i.insert === void 0) && (l(), i = { insert: [] }), i.insert = i.insert.concat(o.content.getContent()), r.add(o)) : ((i === null || i.retain === void 0) && (l(), i = { retain: 0 }), i.retain += o.length);
+        i !== null && i.retain === void 0 && l();
+      }
+      this._changes = e;
+    }
+    return e;
+  }
+}, to = (e, t) => {
+  const r = [];
+  for (; t._item !== null && t !== e; ) {
+    if (t._item.parentSub !== null) r.unshift(t._item.parentSub);
+    else {
+      let n = 0, s = t._item.parent._start;
+      for (; s !== t._item && s !== null; )
+        !s.deleted && s.countable && (n += s.length), s = s.right;
+      r.unshift(n);
+    }
+    t = t._item.parent;
+  }
+  return r;
+}, A = () => {
+  Sl("Invalid access: Add Yjs type to a document before reading data.");
+}, Gn = 80, sr = 0, eo = class {
+  constructor(e, t) {
+    e.marker = !0, this.p = e, this.index = t, this.timestamp = sr++;
+  }
+}, ro = (e) => {
+  e.timestamp = sr++;
+}, Hn = (e, t, r) => {
+  e.p.marker = !1, e.p = t, t.marker = !0, e.index = r, e.timestamp = sr++;
+}, no = (e, t, r) => {
+  if (e.length >= Gn) {
+    const n = e.reduce((s, i) => s.timestamp < i.timestamp ? s : i);
+    return Hn(n, t, r), n;
+  } else {
+    const n = new eo(t, r);
+    return e.push(n), n;
+  }
+}, ie = (e, t) => {
+  if (e._start === null || t === 0 || e._searchMarker === null) return null;
+  const r = e._searchMarker.length === 0 ? null : e._searchMarker.reduce((i, l) => xt(t - i.index) < xt(t - l.index) ? i : l);
+  let n = e._start, s = 0;
+  for (r !== null && (n = r.p, s = r.index, ro(r)); n.right !== null && s < t; ) {
+    if (!n.deleted && n.countable) {
+      if (t < s + n.length) break;
+      s += n.length;
+    }
+    n = n.right;
+  }
+  for (; n.left !== null && s > t; )
+    n = n.left, !n.deleted && n.countable && (s -= n.length);
+  for (; n.left !== null && n.left.id.client === n.id.client && n.left.id.clock + n.left.length === n.id.clock; )
+    n = n.left, !n.deleted && n.countable && (s -= n.length);
+  return r !== null && xt(r.index - s) < n.parent.length / Gn ? (Hn(r, n, s), r) : no(e._searchMarker, n, s);
+}, _t = (e, t, r) => {
+  for (let n = e.length - 1; n >= 0; n--) {
+    const s = e[n];
+    if (r > 0) {
+      let i = s.p;
+      for (i.marker = !1; i && (i.deleted || !i.countable); )
+        i = i.left, i && !i.deleted && i.countable && (s.index -= i.length);
+      if (i === null || i.marker === !0) {
+        e.splice(n, 1);
+        continue;
+      }
+      s.p = i, i.marker = !0;
+    }
+    (t < s.index || r > 0 && t === s.index) && (s.index = Z(t, s.index + r));
+  }
+}, le = (e, t, r) => {
+  const n = e, s = t.changedParentTypes;
+  for (; J(s, e, () => []).push(r), e._item !== null; )
+    e = e._item.parent;
+  Vn(n._eH, r, t);
+}, C = class {
+  constructor() {
+    this._item = null, this._map = /* @__PURE__ */ new Map(), this._start = null, this.doc = null, this._length = 0, this._eH = Ar(), this._dEH = Ar(), this._searchMarker = null;
+  }
+  get parent() {
+    return this._item ? this._item.parent : null;
+  }
+  _integrate(e, t) {
+    this.doc = e, this._item = t;
+  }
+  _copy() {
+    throw M();
+  }
+  clone() {
+    throw M();
+  }
+  _write(e) {
+  }
+  get _first() {
+    let e = this._start;
+    for (; e !== null && e.deleted; ) e = e.right;
+    return e;
+  }
+  _callObserver(e, t) {
+    !e.local && this._searchMarker && (this._searchMarker.length = 0);
+  }
+  observe(e) {
+    Ir(this._eH, e);
+  }
+  observeDeep(e) {
+    Ir(this._dEH, e);
+  }
+  unobserve(e) {
+    Tr(this._eH, e);
+  }
+  unobserveDeep(e) {
+    Tr(this._dEH, e);
+  }
+  toJSON() {
+  }
+}, zn = (e, t, r) => {
+  e.doc ?? A(), t < 0 && (t = e._length + t), r < 0 && (r = e._length + r);
+  let n = r - t;
+  const s = [];
+  let i = e._start;
+  for (; i !== null && n > 0; ) {
+    if (i.countable && !i.deleted) {
+      const l = i.content.getContent();
+      if (l.length <= t) t -= l.length;
+      else {
+        for (let o = t; o < l.length && n > 0; o++)
+          s.push(l[o]), n--;
+        t = 0;
+      }
+    }
+    i = i.right;
+  }
+  return s;
+}, Kn = (e) => {
+  e.doc ?? A();
+  const t = [];
+  let r = e._start;
+  for (; r !== null; ) {
+    if (r.countable && !r.deleted) {
+      const n = r.content.getContent();
+      for (let s = 0; s < n.length; s++) t.push(n[s]);
+    }
+    r = r.right;
+  }
+  return t;
+}, bt = (e, t) => {
+  let r = 0, n = e._start;
+  for (e.doc ?? A(); n !== null; ) {
+    if (n.countable && !n.deleted) {
+      const s = n.content.getContent();
+      for (let i = 0; i < s.length; i++) t(s[i], r++, e);
+    }
+    n = n.right;
+  }
+}, Wn = (e, t) => {
+  const r = [];
+  return bt(e, (n, s) => {
+    r.push(t(n, s, e));
+  }), r;
+}, so = (e) => {
+  let t = e._start, r = null, n = 0;
+  return {
+    [Symbol.iterator]() {
+      return this;
+    },
+    next: () => {
+      if (r === null) {
+        for (; t !== null && t.deleted; ) t = t.right;
+        if (t === null) return {
+          done: !0,
+          value: void 0
+        };
+        r = t.content.getContent(), n = 0, t = t.right;
+      }
+      const s = r[n++];
+      return r.length <= n && (r = null), {
+        done: !1,
+        value: s
+      };
+    }
+  };
+}, qn = (e, t) => {
+  e.doc ?? A();
+  const r = ie(e, t);
+  let n = e._start;
+  for (r !== null && (n = r.p, t -= r.index); n !== null; n = n.right) if (!n.deleted && n.countable) {
+    if (t < n.length) return n.content.getContent()[t];
+    t -= n.length;
+  }
+}, Jt = (e, t, r, n) => {
+  let s = r;
+  const i = e.doc, l = i.clientID, o = i.store, c = r === null ? t._start : r.right;
+  let h = [];
+  const a = () => {
+    h.length > 0 && (s = new D(w(l, b(o, l)), s, s && s.lastId, c, c && c.id, t, null, new Gt(h)), s.integrate(e, 0), h = []);
+  };
+  n.forEach((d) => {
+    if (d === null) h.push(d);
+    else switch (d.constructor) {
+      case Number:
+      case Object:
+      case Boolean:
+      case Array:
+      case String:
+        h.push(d);
+        break;
+      default:
+        switch (a(), d.constructor) {
+          case Uint8Array:
+          case ArrayBuffer:
+            s = new D(w(l, b(o, l)), s, s && s.lastId, c, c && c.id, t, null, new ur(new Uint8Array(d))), s.integrate(e, 0);
+            break;
+          case Pe:
+            s = new D(w(l, b(o, l)), s, s && s.lastId, c, c && c.id, t, null, new dr(d)), s.integrate(e, 0);
+            break;
+          default:
+            if (d instanceof C)
+              s = new D(w(l, b(o, l)), s, s && s.lastId, c, c && c.id, t, null, new P(d)), s.integrate(e, 0);
+            else throw new Error("Unexpected content type in insert operation");
+        }
+    }
+  }), a();
+}, Zn = () => V("Length exceeded!"), Qn = (e, t, r, n) => {
+  if (r > t._length) throw Zn();
+  if (r === 0)
+    return t._searchMarker && _t(t._searchMarker, r, n.length), Jt(e, t, null, n);
+  const s = r, i = ie(t, r);
+  let l = t._start;
+  for (i !== null && (l = i.p, r -= i.index, r === 0 && (l = l.prev, r += l && l.countable && !l.deleted ? l.length : 0)); l !== null; l = l.right) if (!l.deleted && l.countable) {
+    if (r <= l.length) {
+      r < l.length && z(e, w(l.id.client, l.id.clock + r));
+      break;
+    }
+    r -= l.length;
+  }
+  return t._searchMarker && _t(t._searchMarker, s, n.length), Jt(e, t, l, n);
+}, io = (e, t, r) => {
+  let n = (t._searchMarker || []).reduce((s, i) => i.index > s.index ? i : s, {
+    index: 0,
+    p: t._start
+  }).p;
+  if (n) for (; n.right; ) n = n.right;
+  return Jt(e, t, n, r);
+}, Pn = (e, t, r, n) => {
+  if (n === 0) return;
+  const s = r, i = n, l = ie(t, r);
+  let o = t._start;
+  for (l !== null && (o = l.p, r -= l.index); o !== null && r > 0; o = o.right) !o.deleted && o.countable && (r < o.length && z(e, w(o.id.client, o.id.clock + r)), r -= o.length);
+  for (; n > 0 && o !== null; )
+    o.deleted || (n < o.length && z(e, w(o.id.client, o.id.clock + n)), o.delete(e), n -= o.length), o = o.right;
+  if (n > 0) throw Zn();
+  t._searchMarker && _t(t._searchMarker, s, -i + n);
+}, Xt = (e, t, r) => {
+  const n = t._map.get(r);
+  n !== void 0 && n.delete(e);
+}, ir = (e, t, r, n) => {
+  const s = t._map.get(r) || null, i = e.doc, l = i.clientID;
+  let o;
+  if (n == null) o = new Gt([n]);
+  else switch (n.constructor) {
+    case Number:
+    case Object:
+    case Boolean:
+    case Array:
+    case String:
+    case Date:
+    case BigInt:
+      o = new Gt([n]);
+      break;
+    case Uint8Array:
+      o = new ur(n);
+      break;
+    case Pe:
+      o = new dr(n);
+      break;
+    default:
+      if (n instanceof C) o = new P(n);
+      else throw new Error("Unexpected content type");
+  }
+  new D(w(l, b(i.store, l)), s, s && s.lastId, null, null, t, r, o).integrate(e, 0);
+}, lr = (e, t) => {
+  e.doc ?? A();
+  const r = e._map.get(t);
+  return r !== void 0 && !r.deleted ? r.content.getContent()[r.length - 1] : void 0;
+}, ts = (e) => {
+  const t = {};
+  return e.doc ?? A(), e._map.forEach((r, n) => {
+    r.deleted || (t[n] = r.content.getContent()[r.length - 1]);
+  }), t;
+}, es = (e, t) => {
+  e.doc ?? A();
+  const r = e._map.get(t);
+  return r !== void 0 && !r.deleted;
+}, lo = (e, t) => {
+  const r = {};
+  return e._map.forEach((n, s) => {
+    let i = n;
+    for (; i !== null && (!t.sv.has(i.id.client) || i.id.clock >= (t.sv.get(i.id.client) || 0)); ) i = i.left;
+    i !== null && et(i, t) && (r[s] = i.content.getContent()[i.length - 1]);
+  }), r;
+}, Tt = (e) => (e.doc ?? A(), Cl(e._map.entries(), (t) => !t[1].deleted)), oo = class extends se {
+}, rs = class Ut extends C {
+  constructor() {
+    super(), this._prelimContent = [], this._searchMarker = [];
+  }
+  static from(t) {
+    const r = new Ut();
+    return r.push(t), r;
+  }
+  _integrate(t, r) {
+    super._integrate(t, r), this.insert(0, this._prelimContent), this._prelimContent = null;
+  }
+  _copy() {
+    return new Ut();
+  }
+  clone() {
+    const t = new Ut();
+    return t.insert(0, this.toArray().map((r) => r instanceof C ? r.clone() : r)), t;
+  }
+  get length() {
+    return this.doc ?? A(), this._length;
+  }
+  _callObserver(t, r) {
+    super._callObserver(t, r), le(this, t, new oo(this, t));
+  }
+  insert(t, r) {
+    this.doc !== null ? m(this.doc, (n) => {
+      Qn(n, this, t, r);
+    }) : this._prelimContent.splice(t, 0, ...r);
+  }
+  push(t) {
+    this.doc !== null ? m(this.doc, (r) => {
+      io(r, this, t);
+    }) : this._prelimContent.push(...t);
+  }
+  unshift(t) {
+    this.insert(0, t);
+  }
+  delete(t, r = 1) {
+    this.doc !== null ? m(this.doc, (n) => {
+      Pn(n, this, t, r);
+    }) : this._prelimContent.splice(t, r);
+  }
+  get(t) {
+    return qn(this, t);
+  }
+  toArray() {
+    return Kn(this);
+  }
+  slice(t = 0, r = this.length) {
+    return zn(this, t, r);
+  }
+  toJSON() {
+    return this.map((t) => t instanceof C ? t.toJSON() : t);
+  }
+  map(t) {
+    return Wn(this, t);
+  }
+  forEach(t) {
+    bt(this, t);
+  }
+  [Symbol.iterator]() {
+    return so(this);
+  }
+  _write(t) {
+    t.writeTypeRef(Uo);
+  }
+}, co = (e) => new rs(), ao = class extends se {
+  constructor(e, t, r) {
+    super(e, t), this.keysChanged = r;
+  }
+}, or = class Ee extends C {
+  constructor(t) {
+    super(), this._prelimContent = null, t === void 0 ? this._prelimContent = /* @__PURE__ */ new Map() : this._prelimContent = new Map(t);
+  }
+  _integrate(t, r) {
+    super._integrate(t, r), this._prelimContent.forEach((n, s) => {
+      this.set(s, n);
+    }), this._prelimContent = null;
+  }
+  _copy() {
+    return new Ee();
+  }
+  clone() {
+    const t = new Ee();
+    return this.forEach((r, n) => {
+      t.set(n, r instanceof C ? r.clone() : r);
+    }), t;
+  }
+  _callObserver(t, r) {
+    le(this, t, new ao(this, t, r));
+  }
+  toJSON() {
+    this.doc ?? A();
+    const t = {};
+    return this._map.forEach((r, n) => {
+      if (!r.deleted) {
+        const s = r.content.getContent()[r.length - 1];
+        t[n] = s instanceof C ? s.toJSON() : s;
+      }
+    }), t;
+  }
+  get size() {
+    return [...Tt(this)].length;
+  }
+  keys() {
+    return ge(Tt(this), (t) => t[0]);
+  }
+  values() {
+    return ge(Tt(this), (t) => t[1].content.getContent()[t[1].length - 1]);
+  }
+  entries() {
+    return ge(Tt(this), (t) => [t[0], t[1].content.getContent()[t[1].length - 1]]);
+  }
+  forEach(t) {
+    this.doc ?? A(), this._map.forEach((r, n) => {
+      r.deleted || t(r.content.getContent()[r.length - 1], n, this);
+    });
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  delete(t) {
+    this.doc !== null ? m(this.doc, (r) => {
+      Xt(r, this, t);
+    }) : this._prelimContent.delete(t);
+  }
+  set(t, r) {
+    return this.doc !== null ? m(this.doc, (n) => {
+      ir(n, this, t, r);
+    }) : this._prelimContent.set(t, r), r;
+  }
+  get(t) {
+    return lr(this, t);
+  }
+  has(t) {
+    return es(this, t);
+  }
+  clear() {
+    this.doc !== null ? m(this.doc, (t) => {
+      this.forEach(function(r, n, s) {
+        Xt(t, s, n);
+      });
+    }) : this._prelimContent.clear();
+  }
+  _write(t) {
+    t.writeTypeRef(Ro);
+  }
+}, ho = (e) => new or(), H = (e, t) => e === t || typeof e == "object" && typeof t == "object" && e && t && _i(e, t), De = class {
+  constructor(e, t, r, n) {
+    this.left = e, this.right = t, this.index = r, this.currentAttributes = n;
+  }
+  forward() {
+    this.right === null && N(), this.right.content.constructor === E ? this.right.deleted || ft(this.currentAttributes, this.right.content) : this.right.deleted || (this.index += this.right.length), this.left = this.right, this.right = this.right.right;
+  }
+}, Nr = (e, t, r) => {
+  for (; t.right !== null && r > 0; )
+    t.right.content.constructor === E ? t.right.deleted || ft(t.currentAttributes, t.right.content) : t.right.deleted || (r < t.right.length && z(e, w(t.right.id.client, t.right.id.clock + r)), t.index += t.right.length, r -= t.right.length), t.left = t.right, t.right = t.right.right;
+  return t;
+}, Ot = (e, t, r, n) => {
+  const s = /* @__PURE__ */ new Map(), i = n ? ie(t, r) : null;
+  if (i) {
+    const l = new De(i.p.left, i.p, i.index, s);
+    return Nr(e, l, r - i.index);
+  } else {
+    const l = new De(null, t._start, 0, s);
+    return Nr(e, l, r);
+  }
+}, ns = (e, t, r, n) => {
+  for (; r.right !== null && (r.right.deleted === !0 || r.right.content.constructor === E && H(n.get(r.right.content.key), r.right.content.value)); )
+    r.right.deleted || n.delete(r.right.content.key), r.forward();
+  const s = e.doc, i = s.clientID;
+  n.forEach((l, o) => {
+    const c = r.left, h = r.right, a = new D(w(i, b(s.store, i)), c, c && c.lastId, h, h && h.id, t, null, new E(o, l));
+    a.integrate(e, 0), r.right = a, r.forward();
+  });
+}, ft = (e, t) => {
+  const { key: r, value: n } = t;
+  n === null ? e.delete(r) : e.set(r, n);
+}, ss = (e, t) => {
+  for (; e.right !== null; ) {
+    if (!(e.right.deleted || e.right.content.constructor === E && H(t[e.right.content.key] ?? null, e.right.content.value))) break;
+    e.forward();
+  }
+}, is = (e, t, r, n) => {
+  const s = e.doc, i = s.clientID, l = /* @__PURE__ */ new Map();
+  for (const o in n) {
+    const c = n[o], h = r.currentAttributes.get(o) ?? null;
+    if (!H(h, c)) {
+      l.set(o, h);
+      const { left: a, right: d } = r;
+      r.right = new D(w(i, b(s.store, i)), a, a && a.lastId, d, d && d.id, t, null, new E(o, c)), r.right.integrate(e, 0), r.forward();
+    }
+  }
+  return l;
+}, ve = (e, t, r, n, s) => {
+  r.currentAttributes.forEach((u, f) => {
+    s[f] === void 0 && (s[f] = null);
+  });
+  const i = e.doc, l = i.clientID;
+  ss(r, s);
+  const o = is(e, t, r, s), c = n.constructor === String ? new q(n) : n instanceof C ? new P(n) : new At(n);
+  let { left: h, right: a, index: d } = r;
+  t._searchMarker && _t(t._searchMarker, r.index, c.getLength()), a = new D(w(l, b(i.store, l)), h, h && h.lastId, a, a && a.id, t, null, c), a.integrate(e, 0), r.right = a, r.index = d, r.forward(), ns(e, t, r, o);
+}, Mr = (e, t, r, n, s) => {
+  const i = e.doc, l = i.clientID;
+  ss(r, s);
+  const o = is(e, t, r, s);
+  t: for (; r.right !== null && (n > 0 || o.size > 0 && (r.right.deleted || r.right.content.constructor === E)); ) {
+    if (!r.right.deleted) switch (r.right.content.constructor) {
+      case E: {
+        const { key: c, value: h } = r.right.content, a = s[c];
+        if (a !== void 0) {
+          if (H(a, h)) o.delete(c);
+          else {
+            if (n === 0) break t;
+            o.set(c, h);
+          }
+          r.right.delete(e);
+        } else r.currentAttributes.set(c, h);
+        break;
+      }
+      default:
+        n < r.right.length && z(e, w(r.right.id.client, r.right.id.clock + n)), n -= r.right.length;
+        break;
+    }
+    r.forward();
+  }
+  if (n > 0) {
+    let c = "";
+    for (; n > 0; n--) c += `
+`;
+    r.right = new D(w(l, b(i.store, l)), r.left, r.left && r.left.lastId, r.right, r.right && r.right.id, t, null, new q(c)), r.right.integrate(e, 0), r.forward();
+  }
+  ns(e, t, r, o);
+}, ls = (e, t, r, n, s) => {
+  let i = t;
+  const l = T();
+  for (; i && (!i.countable || i.deleted); ) {
+    if (!i.deleted && i.content.constructor === E) {
+      const h = i.content;
+      l.set(h.key, h);
+    }
+    i = i.right;
+  }
+  let o = 0, c = !1;
+  for (; t !== i; ) {
+    if (r === t && (c = !0), !t.deleted) {
+      const h = t.content;
+      if (h.constructor === E) {
+        const { key: a, value: d } = h, u = n.get(a) ?? null;
+        (l.get(a) !== h || u === d) && (t.delete(e), o++, !c && (s.get(a) ?? null) === d && u !== d && (u === null ? s.delete(a) : s.set(a, u))), !c && !t.deleted && ft(s, h);
+      }
+    }
+    t = t.right;
+  }
+  return o;
+}, uo = (e, t) => {
+  for (; t && t.right && (t.right.deleted || !t.right.countable); ) t = t.right;
+  const r = /* @__PURE__ */ new Set();
+  for (; t && (t.deleted || !t.countable); ) {
+    if (!t.deleted && t.content.constructor === E) {
+      const n = t.content.key;
+      r.has(n) ? t.delete(e) : r.add(n);
+    }
+    t = t.left;
+  }
+}, fo = (e) => {
+  let t = 0;
+  return m(e.doc, (r) => {
+    let n = e._start, s = e._start, i = T();
+    const l = me(i);
+    for (; s; )
+      s.deleted === !1 && (s.content.constructor === E ? ft(l, s.content) : (t += ls(r, n, s, i, l), i = me(l), n = s)), s = s.right;
+  }), t;
+}, go = (e) => {
+  const t = /* @__PURE__ */ new Set(), r = e.doc;
+  for (const [n, s] of e.afterState.entries()) {
+    const i = e.beforeState.get(n) || 0;
+    s !== i && Yn(e, r.store.clients.get(n), i, s, (l) => {
+      !l.deleted && l.content.constructor === E && l.constructor !== L && t.add(l.parent);
+    });
+  }
+  m(r, (n) => {
+    An(e, e.deleteSet, (s) => {
+      if (s instanceof L || !s.parent._hasFormatting || t.has(s.parent)) return;
+      const i = s.parent;
+      s.content.constructor === E ? t.add(i) : uo(n, s);
+    });
+    for (const s of t) fo(s);
+  });
+}, Ur = (e, t, r) => {
+  const n = r, s = me(t.currentAttributes), i = t.right;
+  for (; r > 0 && t.right !== null; ) {
+    if (t.right.deleted === !1) switch (t.right.content.constructor) {
+      case P:
+      case At:
+      case q:
+        r < t.right.length && z(e, w(t.right.id.client, t.right.id.clock + r)), r -= t.right.length, t.right.delete(e);
+        break;
+    }
+    t.forward();
+  }
+  i && ls(e, i, t.right, s, t.currentAttributes);
+  const l = (t.left || t.right).parent;
+  return l._searchMarker && _t(l._searchMarker, t.index, -n + r), t;
+}, po = class extends se {
+  constructor(e, t, r) {
+    super(e, t), this.childListChanged = !1, this.keysChanged = /* @__PURE__ */ new Set(), r.forEach((n) => {
+      n === null ? this.childListChanged = !0 : this.keysChanged.add(n);
+    });
+  }
+  get changes() {
+    if (this._changes === null) {
+      const e = {
+        keys: this.keys,
+        delta: this.delta,
+        added: /* @__PURE__ */ new Set(),
+        deleted: /* @__PURE__ */ new Set()
+      };
+      this._changes = e;
+    }
+    return this._changes;
+  }
+  get delta() {
+    if (this._delta === null) {
+      const e = this.target.doc, t = [];
+      m(e, (r) => {
+        const n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+        let i = this.target._start, l = null;
+        const o = {};
+        let c = "", h = 0, a = 0;
+        const d = () => {
+          if (l !== null) {
+            let u = null;
+            switch (l) {
+              case "delete":
+                a > 0 && (u = { delete: a }), a = 0;
+                break;
+              case "insert":
+                (typeof c == "object" || c.length > 0) && (u = { insert: c }, n.size > 0 && (u.attributes = {}, n.forEach((f, g) => {
+                  f !== null && (u.attributes[g] = f);
+                }))), c = "";
+                break;
+              case "retain":
+                h > 0 && (u = { retain: h }, ki(o) || (u.attributes = wi({}, o))), h = 0;
+                break;
+            }
+            u && t.push(u), l = null;
+          }
+        };
+        for (; i !== null; ) {
+          switch (i.content.constructor) {
+            case P:
+            case At:
+              this.adds(i) ? this.deletes(i) || (d(), l = "insert", c = i.content.getContent()[0], d()) : this.deletes(i) ? (l !== "delete" && (d(), l = "delete"), a += 1) : i.deleted || (l !== "retain" && (d(), l = "retain"), h += 1);
+              break;
+            case q:
+              this.adds(i) ? this.deletes(i) || (l !== "insert" && (d(), l = "insert"), c += i.content.str) : this.deletes(i) ? (l !== "delete" && (d(), l = "delete"), a += i.length) : i.deleted || (l !== "retain" && (d(), l = "retain"), h += i.length);
+              break;
+            case E: {
+              const { key: u, value: f } = i.content;
+              if (this.adds(i)) {
+                if (!this.deletes(i)) {
+                  const g = n.get(u) ?? null;
+                  H(g, f) ? f !== null && i.delete(r) : (l === "retain" && d(), H(f, s.get(u) ?? null) ? delete o[u] : o[u] = f);
+                }
+              } else if (this.deletes(i)) {
+                s.set(u, f);
+                const g = n.get(u) ?? null;
+                H(g, f) || (l === "retain" && d(), o[u] = g);
+              } else if (!i.deleted) {
+                s.set(u, f);
+                const g = o[u];
+                g !== void 0 && (H(g, f) ? g !== null && i.delete(r) : (l === "retain" && d(), f === null ? delete o[u] : o[u] = f));
+              }
+              i.deleted || (l === "insert" && d(), ft(n, i.content));
+              break;
+            }
+          }
+          i = i.right;
+        }
+        for (d(); t.length > 0; ) {
+          const u = t[t.length - 1];
+          if (u.retain !== void 0 && u.attributes === void 0) t.pop();
+          else break;
+        }
+      }), this._delta = t;
+    }
+    return this._delta;
+  }
+}, cr = class Ae extends C {
+  constructor(t) {
+    super(), this._pending = t !== void 0 ? [() => this.insert(0, t)] : [], this._searchMarker = [], this._hasFormatting = !1;
+  }
+  get length() {
+    return this.doc ?? A(), this._length;
+  }
+  _integrate(t, r) {
+    super._integrate(t, r);
+    try {
+      this._pending.forEach((n) => n());
+    } catch (n) {
+      console.error(n);
+    }
+    this._pending = null;
+  }
+  _copy() {
+    return new Ae();
+  }
+  clone() {
+    const t = new Ae();
+    return t.applyDelta(this.toDelta()), t;
+  }
+  _callObserver(t, r) {
+    super._callObserver(t, r);
+    const n = new po(this, t, r);
+    le(this, t, n), !t.local && this._hasFormatting && (t._needFormattingCleanup = !0);
+  }
+  toString() {
+    this.doc ?? A();
+    let t = "", r = this._start;
+    for (; r !== null; )
+      !r.deleted && r.countable && r.content.constructor === q && (t += r.content.str), r = r.right;
+    return t;
+  }
+  toJSON() {
+    return this.toString();
+  }
+  applyDelta(t, { sanitize: r = !0 } = {}) {
+    this.doc !== null ? m(this.doc, (n) => {
+      const s = new De(null, this._start, 0, /* @__PURE__ */ new Map());
+      for (let i = 0; i < t.length; i++) {
+        const l = t[i];
+        if (l.insert !== void 0) {
+          const o = !r && typeof l.insert == "string" && i === t.length - 1 && s.right === null && l.insert.slice(-1) === `
+` ? l.insert.slice(0, -1) : l.insert;
+          (typeof o != "string" || o.length > 0) && ve(n, this, s, o, l.attributes || {});
+        } else l.retain !== void 0 ? Mr(n, this, s, l.retain, l.attributes || {}) : l.delete !== void 0 && Ur(n, s, l.delete);
+      }
+    }) : this._pending.push(() => this.applyDelta(t));
+  }
+  toDelta(t, r, n) {
+    this.doc ?? A();
+    const s = [], i = /* @__PURE__ */ new Map(), l = this.doc;
+    let o = "", c = this._start;
+    function h() {
+      if (o.length > 0) {
+        const d = {};
+        let u = !1;
+        i.forEach((g, y) => {
+          u = !0, d[y] = g;
+        });
+        const f = { insert: o };
+        u && (f.attributes = d), s.push(f), o = "";
+      }
+    }
+    const a = () => {
+      for (; c !== null; ) {
+        if (et(c, t) || r !== void 0 && et(c, r)) switch (c.content.constructor) {
+          case q: {
+            const d = i.get("ychange");
+            t !== void 0 && !et(c, t) ? (d === void 0 || d.user !== c.id.client || d.type !== "removed") && (h(), i.set("ychange", n ? n("removed", c.id) : { type: "removed" })) : r !== void 0 && !et(c, r) ? (d === void 0 || d.user !== c.id.client || d.type !== "added") && (h(), i.set("ychange", n ? n("added", c.id) : { type: "added" })) : d !== void 0 && (h(), i.delete("ychange")), o += c.content.str;
+            break;
+          }
+          case P:
+          case At: {
+            h();
+            const d = { insert: c.content.getContent()[0] };
+            if (i.size > 0) {
+              const u = {};
+              d.attributes = u, i.forEach((f, g) => {
+                u[g] = f;
+              });
+            }
+            s.push(d);
+            break;
+          }
+          case E:
+            et(c, t) && (h(), ft(i, c.content));
+            break;
+        }
+        c = c.right;
+      }
+      h();
+    };
+    return t || r ? m(l, (d) => {
+      t && Se(d, t), r && Se(d, r), a();
+    }, "cleanup") : a(), s;
+  }
+  insert(t, r, n) {
+    if (r.length <= 0) return;
+    const s = this.doc;
+    s !== null ? m(s, (i) => {
+      const l = Ot(i, this, t, !n);
+      n || (n = {}, l.currentAttributes.forEach((o, c) => {
+        n[c] = o;
+      })), ve(i, this, l, r, n);
+    }) : this._pending.push(() => this.insert(t, r, n));
+  }
+  insertEmbed(t, r, n) {
+    const s = this.doc;
+    s !== null ? m(s, (i) => {
+      const l = Ot(i, this, t, !n);
+      ve(i, this, l, r, n || {});
+    }) : this._pending.push(() => this.insertEmbed(t, r, n || {}));
+  }
+  delete(t, r) {
+    if (r === 0) return;
+    const n = this.doc;
+    n !== null ? m(n, (s) => {
+      Ur(s, Ot(s, this, t, !0), r);
+    }) : this._pending.push(() => this.delete(t, r));
+  }
+  format(t, r, n) {
+    if (r === 0) return;
+    const s = this.doc;
+    s !== null ? m(s, (i) => {
+      const l = Ot(i, this, t, !1);
+      l.right !== null && Mr(i, this, l, r, n);
+    }) : this._pending.push(() => this.format(t, r, n));
+  }
+  removeAttribute(t) {
+    this.doc !== null ? m(this.doc, (r) => {
+      Xt(r, this, t);
+    }) : this._pending.push(() => this.removeAttribute(t));
+  }
+  setAttribute(t, r) {
+    this.doc !== null ? m(this.doc, (n) => {
+      ir(n, this, t, r);
+    }) : this._pending.push(() => this.setAttribute(t, r));
+  }
+  getAttribute(t) {
+    return lr(this, t);
+  }
+  getAttributes() {
+    return ts(this);
+  }
+  _write(t) {
+    t.writeTypeRef(Bo);
+  }
+}, vo = (e) => new cr(), we = class {
+  constructor(e, t = () => !0) {
+    this._filter = t, this._root = e, this._currentNode = e._start, this._firstCall = !0, e.doc ?? A();
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    let e = this._currentNode, t = e && e.content && e.content.type;
+    if (e !== null && (!this._firstCall || e.deleted || !this._filter(t))) do
+      if (t = e.content.type, !e.deleted && (t.constructor === ar || t.constructor === oe) && t._start !== null) e = t._start;
+      else for (; e !== null; ) {
+        const r = e.next;
+        if (r !== null) {
+          e = r;
+          break;
+        } else e.parent === this._root ? e = null : e = e.parent._item;
+      }
+    while (e !== null && (e.deleted || !this._filter(e.content.type)));
+    return this._firstCall = !1, e === null ? {
+      value: void 0,
+      done: !0
+    } : (this._currentNode = e, {
+      value: e.content.type,
+      done: !1
+    });
+  }
+}, oe = class Ie extends C {
+  constructor() {
+    super(), this._prelimContent = [];
+  }
+  get firstChild() {
+    const t = this._first;
+    return t ? t.content.getContent()[0] : null;
+  }
+  _integrate(t, r) {
+    super._integrate(t, r), this.insert(0, this._prelimContent), this._prelimContent = null;
+  }
+  _copy() {
+    return new Ie();
+  }
+  clone() {
+    const t = new Ie();
+    return t.insert(0, this.toArray().map((r) => r instanceof C ? r.clone() : r)), t;
+  }
+  get length() {
+    return this.doc ?? A(), this._prelimContent === null ? this._length : this._prelimContent.length;
+  }
+  createTreeWalker(t) {
+    return new we(this, t);
+  }
+  querySelector(t) {
+    t = t.toUpperCase();
+    const r = new we(this, (n) => n.nodeName && n.nodeName.toUpperCase() === t).next();
+    return r.done ? null : r.value;
+  }
+  querySelectorAll(t) {
+    return t = t.toUpperCase(), Y(new we(this, (r) => r.nodeName && r.nodeName.toUpperCase() === t));
+  }
+  _callObserver(t, r) {
+    le(this, t, new yo(this, r, t));
+  }
+  toString() {
+    return Wn(this, (t) => t.toString()).join("");
+  }
+  toJSON() {
+    return this.toString();
+  }
+  toDOM(t = document, r = {}, n) {
+    const s = t.createDocumentFragment();
+    return n !== void 0 && n._createAssociation(s, this), bt(this, (i) => {
+      s.insertBefore(i.toDOM(t, r, n), null);
+    }), s;
+  }
+  insert(t, r) {
+    this.doc !== null ? m(this.doc, (n) => {
+      Qn(n, this, t, r);
+    }) : this._prelimContent.splice(t, 0, ...r);
+  }
+  insertAfter(t, r) {
+    if (this.doc !== null) m(this.doc, (n) => {
+      const s = t && t instanceof C ? t._item : t;
+      Jt(n, this, s, r);
+    });
+    else {
+      const n = this._prelimContent, s = t === null ? 0 : n.findIndex((i) => i === t) + 1;
+      if (s === 0 && t !== null) throw V("Reference item not found");
+      n.splice(s, 0, ...r);
+    }
+  }
+  delete(t, r = 1) {
+    this.doc !== null ? m(this.doc, (n) => {
+      Pn(n, this, t, r);
+    }) : this._prelimContent.splice(t, r);
+  }
+  toArray() {
+    return Kn(this);
+  }
+  push(t) {
+    this.insert(this.length, t);
+  }
+  unshift(t) {
+    this.insert(0, t);
+  }
+  get(t) {
+    return qn(this, t);
+  }
+  slice(t = 0, r = this.length) {
+    return zn(this, t, r);
+  }
+  forEach(t) {
+    bt(this, t);
+  }
+  _write(t) {
+    t.writeTypeRef(Fo);
+  }
+}, wo = (e) => new oe(), ar = class Te extends oe {
+  constructor(t = "UNDEFINED") {
+    super(), this.nodeName = t, this._prelimAttrs = /* @__PURE__ */ new Map();
+  }
+  get nextSibling() {
+    const t = this._item ? this._item.next : null;
+    return t ? t.content.type : null;
+  }
+  get prevSibling() {
+    const t = this._item ? this._item.prev : null;
+    return t ? t.content.type : null;
+  }
+  _integrate(t, r) {
+    super._integrate(t, r), this._prelimAttrs.forEach((n, s) => {
+      this.setAttribute(s, n);
+    }), this._prelimAttrs = null;
+  }
+  _copy() {
+    return new Te(this.nodeName);
+  }
+  clone() {
+    const t = new Te(this.nodeName), r = this.getAttributes();
+    return yi(r, (n, s) => {
+      t.setAttribute(s, n);
+    }), t.insert(0, this.toArray().map((n) => n instanceof C ? n.clone() : n)), t;
+  }
+  toString() {
+    const t = this.getAttributes(), r = [], n = [];
+    for (const l in t) n.push(l);
+    n.sort();
+    const s = n.length;
+    for (let l = 0; l < s; l++) {
+      const o = n[l];
+      r.push(o + '="' + t[o] + '"');
+    }
+    const i = this.nodeName.toLocaleLowerCase();
+    return `<${i}${r.length > 0 ? " " + r.join(" ") : ""}>${super.toString()}</${i}>`;
+  }
+  removeAttribute(t) {
+    this.doc !== null ? m(this.doc, (r) => {
+      Xt(r, this, t);
+    }) : this._prelimAttrs.delete(t);
+  }
+  setAttribute(t, r) {
+    this.doc !== null ? m(this.doc, (n) => {
+      ir(n, this, t, r);
+    }) : this._prelimAttrs.set(t, r);
+  }
+  getAttribute(t) {
+    return lr(this, t);
+  }
+  hasAttribute(t) {
+    return es(this, t);
+  }
+  getAttributes(t) {
+    return t ? lo(this, t) : ts(this);
+  }
+  toDOM(t = document, r = {}, n) {
+    const s = t.createElement(this.nodeName), i = this.getAttributes();
+    for (const l in i) {
+      const o = i[l];
+      typeof o == "string" && s.setAttribute(l, o);
+    }
+    return bt(this, (l) => {
+      s.appendChild(l.toDOM(t, r, n));
+    }), n !== void 0 && n._createAssociation(s, this), s;
+  }
+  _write(t) {
+    t.writeTypeRef(Vo), t.writeKey(this.nodeName);
+  }
+}, mo = (e) => new ar(e.readKey()), yo = class extends se {
+  constructor(e, t, r) {
+    super(e, r), this.childListChanged = !1, this.attributesChanged = /* @__PURE__ */ new Set(), t.forEach((n) => {
+      n === null ? this.childListChanged = !0 : this.attributesChanged.add(n);
+    });
+  }
+}, ko = class Oe extends or {
+  constructor(t) {
+    super(), this.hookName = t;
+  }
+  _copy() {
+    return new Oe(this.hookName);
+  }
+  clone() {
+    const t = new Oe(this.hookName);
+    return this.forEach((r, n) => {
+      t.set(n, r);
+    }), t;
+  }
+  toDOM(t = document, r = {}, n) {
+    const s = r[this.hookName];
+    let i;
+    return s !== void 0 ? i = s.createDom(this) : i = document.createElement(this.hookName), i.setAttribute("data-yjs-hook", this.hookName), n !== void 0 && n._createAssociation(i, this), i;
+  }
+  _write(t) {
+    t.writeTypeRef(jo), t.writeKey(this.hookName);
+  }
+}, _o = (e) => new ko(e.readKey()), bo = class xe extends cr {
+  get nextSibling() {
+    const t = this._item ? this._item.next : null;
+    return t ? t.content.type : null;
+  }
+  get prevSibling() {
+    const t = this._item ? this._item.prev : null;
+    return t ? t.content.type : null;
+  }
+  _copy() {
+    return new xe();
+  }
+  clone() {
+    const t = new xe();
+    return t.applyDelta(this.toDelta()), t;
+  }
+  toDOM(t = document, r, n) {
+    const s = t.createTextNode(this.toString());
+    return n !== void 0 && n._createAssociation(s, this), s;
+  }
+  toString() {
+    return this.toDelta().map((t) => {
+      const r = [];
+      for (const s in t.attributes) {
+        const i = [];
+        for (const l in t.attributes[s]) i.push({
+          key: l,
+          value: t.attributes[s][l]
+        });
+        i.sort((l, o) => l.key < o.key ? -1 : 1), r.push({
+          nodeName: s,
+          attrs: i
+        });
+      }
+      r.sort((s, i) => s.nodeName < i.nodeName ? -1 : 1);
+      let n = "";
+      for (let s = 0; s < r.length; s++) {
+        const i = r[s];
+        n += `<${i.nodeName}`;
+        for (let l = 0; l < i.attrs.length; l++) {
+          const o = i.attrs[l];
+          n += ` ${o.key}="${o.value}"`;
+        }
+        n += ">";
+      }
+      n += t.insert;
+      for (let s = r.length - 1; s >= 0; s--) n += `</${r[s].nodeName}>`;
+      return n;
+    }).join("");
+  }
+  toJSON() {
+    return this.toString();
+  }
+  _write(t) {
+    t.writeTypeRef(Yo);
+  }
+}, So = (e) => new bo(), hr = class {
+  constructor(e, t) {
+    this.id = e, this.length = t;
+  }
+  get deleted() {
+    throw M();
+  }
+  mergeWith(e) {
+    return !1;
+  }
+  write(e, t, r) {
+    throw M();
+  }
+  integrate(e, t) {
+    throw M();
+  }
+}, Co = 0, L = class extends hr {
+  get deleted() {
+    return !0;
+  }
+  delete() {
+  }
+  mergeWith(e) {
+    return this.constructor !== e.constructor ? !1 : (this.length += e.length, !0);
+  }
+  integrate(e, t) {
+    t > 0 && (this.id.clock += t, this.length -= t), jn(e.doc.store, this);
+  }
+  write(e, t) {
+    e.writeInfo(Co), e.writeLen(this.length - t);
+  }
+  getMissing(e, t) {
+    return null;
+  }
+}, ur = class os {
+  constructor(t) {
+    this.content = t;
+  }
+  getLength() {
+    return 1;
+  }
+  getContent() {
+    return [this.content];
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new os(this.content);
+  }
+  splice(t) {
+    throw M();
+  }
+  mergeWith(t) {
+    return !1;
+  }
+  integrate(t, r) {
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    t.writeBuf(this.content);
+  }
+  getRef() {
+    return 3;
+  }
+}, Eo = (e) => new ur(e.readBuf()), cs = class Le {
+  constructor(t) {
+    this.len = t;
+  }
+  getLength() {
+    return this.len;
+  }
+  getContent() {
+    return [];
+  }
+  isCountable() {
+    return !1;
+  }
+  copy() {
+    return new Le(this.len);
+  }
+  splice(t) {
+    const r = new Le(this.len - t);
+    return this.len = t, r;
+  }
+  mergeWith(t) {
+    return this.len += t.len, !0;
+  }
+  integrate(t, r) {
+    jt(t.deleteSet, r.id.client, r.id.clock, this.len), r.markDeleted();
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    t.writeLen(this.len - r);
+  }
+  getRef() {
+    return 1;
+  }
+}, Do = (e) => new cs(e.readLen()), as = (e, t) => new Pe({
+  guid: e,
+  ...t,
+  shouldLoad: t.shouldLoad || t.autoLoad || !1
+}), dr = class hs {
+  constructor(t) {
+    t._item && console.error("This document was already integrated as a sub-document. You should create a second instance instead with the same guid."), this.doc = t;
+    const r = {};
+    this.opts = r, t.gc || (r.gc = !1), t.autoLoad && (r.autoLoad = !0), t.meta !== null && (r.meta = t.meta);
+  }
+  getLength() {
+    return 1;
+  }
+  getContent() {
+    return [this.doc];
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new hs(as(this.doc.guid, this.opts));
+  }
+  splice(t) {
+    throw M();
+  }
+  mergeWith(t) {
+    return !1;
+  }
+  integrate(t, r) {
+    this.doc._item = r, t.subdocsAdded.add(this.doc), this.doc.shouldLoad && t.subdocsLoaded.add(this.doc);
+  }
+  delete(t) {
+    t.subdocsAdded.has(this.doc) ? t.subdocsAdded.delete(this.doc) : t.subdocsRemoved.add(this.doc);
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    t.writeString(this.doc.guid), t.writeAny(this.opts);
+  }
+  getRef() {
+    return 9;
+  }
+}, Ao = (e) => new dr(as(e.readString(), e.readAny())), At = class us {
+  constructor(t) {
+    this.embed = t;
+  }
+  getLength() {
+    return 1;
+  }
+  getContent() {
+    return [this.embed];
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new us(this.embed);
+  }
+  splice(t) {
+    throw M();
+  }
+  mergeWith(t) {
+    return !1;
+  }
+  integrate(t, r) {
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    t.writeJSON(this.embed);
+  }
+  getRef() {
+    return 5;
+  }
+}, Io = (e) => new At(e.readJSON()), E = class ds {
+  constructor(t, r) {
+    this.key = t, this.value = r;
+  }
+  getLength() {
+    return 1;
+  }
+  getContent() {
+    return [];
+  }
+  isCountable() {
+    return !1;
+  }
+  copy() {
+    return new ds(this.key, this.value);
+  }
+  splice(t) {
+    throw M();
+  }
+  mergeWith(t) {
+    return !1;
+  }
+  integrate(t, r) {
+    const n = r.parent;
+    n._searchMarker = null, n._hasFormatting = !0;
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    t.writeKey(this.key), t.writeJSON(this.value);
+  }
+  getRef() {
+    return 6;
+  }
+}, To = (e) => new E(e.readKey(), e.readJSON()), Oo = class $e {
+  constructor(t) {
+    this.arr = t;
+  }
+  getLength() {
+    return this.arr.length;
+  }
+  getContent() {
+    return this.arr;
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new $e(this.arr);
+  }
+  splice(t) {
+    const r = new $e(this.arr.slice(t));
+    return this.arr = this.arr.slice(0, t), r;
+  }
+  mergeWith(t) {
+    return this.arr = this.arr.concat(t.arr), !0;
+  }
+  integrate(t, r) {
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    const n = this.arr.length;
+    t.writeLen(n - r);
+    for (let s = r; s < n; s++) {
+      const i = this.arr[s];
+      t.writeString(i === void 0 ? "undefined" : JSON.stringify(i));
+    }
+  }
+  getRef() {
+    return 2;
+  }
+}, xo = (e) => {
+  const t = e.readLen(), r = [];
+  for (let n = 0; n < t; n++) {
+    const s = e.readString();
+    s === "undefined" ? r.push(void 0) : r.push(JSON.parse(s));
+  }
+  return new Oo(r);
+}, Lo = yt("node_env") === "development", Gt = class Ne {
+  constructor(t) {
+    this.arr = t, Lo && Hr(t);
+  }
+  getLength() {
+    return this.arr.length;
+  }
+  getContent() {
+    return this.arr;
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new Ne(this.arr);
+  }
+  splice(t) {
+    const r = new Ne(this.arr.slice(t));
+    return this.arr = this.arr.slice(0, t), r;
+  }
+  mergeWith(t) {
+    return this.arr = this.arr.concat(t.arr), !0;
+  }
+  integrate(t, r) {
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    const n = this.arr.length;
+    t.writeLen(n - r);
+    for (let s = r; s < n; s++) {
+      const i = this.arr[s];
+      t.writeAny(i);
+    }
+  }
+  getRef() {
+    return 8;
+  }
+}, $o = (e) => {
+  const t = e.readLen(), r = [];
+  for (let n = 0; n < t; n++) r.push(e.readAny());
+  return new Gt(r);
+}, q = class Me {
+  constructor(t) {
+    this.str = t;
+  }
+  getLength() {
+    return this.str.length;
+  }
+  getContent() {
+    return this.str.split("");
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new Me(this.str);
+  }
+  splice(t) {
+    const r = new Me(this.str.slice(t));
+    this.str = this.str.slice(0, t);
+    const n = this.str.charCodeAt(t - 1);
+    return n >= 55296 && n <= 56319 && (this.str = this.str.slice(0, t - 1) + "�", r.str = "�" + r.str.slice(1)), r;
+  }
+  mergeWith(t) {
+    return this.str += t.str, !0;
+  }
+  integrate(t, r) {
+  }
+  delete(t) {
+  }
+  gc(t) {
+  }
+  write(t, r) {
+    t.writeString(r === 0 ? this.str : this.str.slice(r));
+  }
+  getRef() {
+    return 4;
+  }
+}, No = (e) => new q(e.readString()), Mo = [
+  co,
+  ho,
+  vo,
+  mo,
+  wo,
+  _o,
+  So
+], Uo = 0, Ro = 1, Bo = 2, Vo = 3, Fo = 4, jo = 5, Yo = 6, P = class fs {
+  constructor(t) {
+    this.type = t;
+  }
+  getLength() {
+    return 1;
+  }
+  getContent() {
+    return [this.type];
+  }
+  isCountable() {
+    return !0;
+  }
+  copy() {
+    return new fs(this.type._copy());
+  }
+  splice(t) {
+    throw M();
+  }
+  mergeWith(t) {
+    return !1;
+  }
+  integrate(t, r) {
+    this.type._integrate(t.doc, r);
+  }
+  delete(t) {
+    let r = this.type._start;
+    for (; r !== null; )
+      r.deleted ? r.id.clock < (t.beforeState.get(r.id.client) || 0) && t._mergeStructs.push(r) : r.delete(t), r = r.right;
+    this.type._map.forEach((n) => {
+      n.deleted ? n.id.clock < (t.beforeState.get(n.id.client) || 0) && t._mergeStructs.push(n) : n.delete(t);
+    }), t.changed.delete(this.type);
+  }
+  gc(t) {
+    let r = this.type._start;
+    for (; r !== null; )
+      r.gc(t, !0), r = r.right;
+    this.type._start = null, this.type._map.forEach((n) => {
+      for (; n !== null; )
+        n.gc(t, !0), n = n.left;
+    }), this.type._map = /* @__PURE__ */ new Map();
+  }
+  write(t, r) {
+    this.type._write(t);
+  }
+  getRef() {
+    return 7;
+  }
+}, Jo = (e) => new P(Mo[e.readTypeRef()](e)), Ht = (e, t, r) => {
+  const { client: n, clock: s } = t.id, i = new D(w(n, s + r), t, w(n, s + r - 1), t.right, t.rightOrigin, t.parent, t.parentSub, t.content.splice(r));
+  return t.deleted && i.markDeleted(), t.keep && (i.keep = !0), t.redone !== null && (i.redone = w(t.redone.client, t.redone.clock + r)), t.right = i, i.right !== null && (i.right.left = i), e._mergeStructs.push(i), i.parentSub !== null && i.right === null && i.parent._map.set(i.parentSub, i), t.length = r, i;
+}, D = class Ue extends hr {
+  constructor(t, r, n, s, i, l, o, c) {
+    super(t, c.getLength()), this.origin = n, this.left = r, this.right = s, this.rightOrigin = i, this.parent = l, this.parentSub = o, this.redone = null, this.content = c, this.info = this.content.isCountable() ? 2 : 0;
+  }
+  set marker(t) {
+    (this.info & 8) > 0 !== t && (this.info ^= 8);
+  }
+  get marker() {
+    return (this.info & 8) > 0;
+  }
+  get keep() {
+    return (this.info & 1) > 0;
+  }
+  set keep(t) {
+    this.keep !== t && (this.info ^= 1);
+  }
+  get countable() {
+    return (this.info & 2) > 0;
+  }
+  get deleted() {
+    return (this.info & 4) > 0;
+  }
+  set deleted(t) {
+    this.deleted !== t && (this.info ^= 4);
+  }
+  markDeleted() {
+    this.info |= 4;
+  }
+  getMissing(t, r) {
+    if (this.origin && this.origin.client !== this.id.client && this.origin.clock >= b(r, this.origin.client)) return this.origin.client;
+    if (this.rightOrigin && this.rightOrigin.client !== this.id.client && this.rightOrigin.clock >= b(r, this.rightOrigin.client)) return this.rightOrigin.client;
+    if (this.parent && this.parent.constructor === it && this.id.client !== this.parent.client && this.parent.clock >= b(r, this.parent.client)) return this.parent.client;
+    if (this.origin && (this.left = Or(t, r, this.origin), this.origin = this.left.lastId), this.rightOrigin && (this.right = z(t, this.rightOrigin), this.rightOrigin = this.right.id), this.left && this.left.constructor === L || this.right && this.right.constructor === L) this.parent = null;
+    else if (!this.parent)
+      this.left && this.left.constructor === Ue ? (this.parent = this.left.parent, this.parentSub = this.left.parentSub) : this.right && this.right.constructor === Ue && (this.parent = this.right.parent, this.parentSub = this.right.parentSub);
+    else if (this.parent.constructor === it) {
+      const n = pe(r, this.parent);
+      n.constructor === L ? this.parent = null : this.parent = n.content.type;
+    }
+    return null;
+  }
+  integrate(t, r) {
+    if (r > 0 && (this.id.clock += r, this.left = Or(t, t.doc.store, w(this.id.client, this.id.clock - 1)), this.origin = this.left.lastId, this.content = this.content.splice(r), this.length -= r), this.parent) {
+      if (!this.left && (!this.right || this.right.left !== null) || this.left && this.left.right !== this.right) {
+        let n = this.left, s;
+        if (n !== null) s = n.right;
+        else if (this.parentSub !== null)
+          for (s = this.parent._map.get(this.parentSub) || null; s !== null && s.left !== null; ) s = s.left;
+        else s = this.parent._start;
+        const i = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set();
+        for (; s !== null && s !== this.right; ) {
+          if (l.add(s), i.add(s), It(this.origin, s.origin)) {
+            if (s.id.client < this.id.client)
+              n = s, i.clear();
+            else if (It(this.rightOrigin, s.rightOrigin)) break;
+          } else if (s.origin !== null && l.has(pe(t.doc.store, s.origin)))
+            i.has(pe(t.doc.store, s.origin)) || (n = s, i.clear());
+          else break;
+          s = s.right;
+        }
+        this.left = n;
+      }
+      if (this.left !== null) {
+        const n = this.left.right;
+        this.right = n, this.left.right = this;
+      } else {
+        let n;
+        if (this.parentSub !== null)
+          for (n = this.parent._map.get(this.parentSub) || null; n !== null && n.left !== null; ) n = n.left;
+        else
+          n = this.parent._start, this.parent._start = this;
+        this.right = n;
+      }
+      this.right !== null ? this.right.left = this : this.parentSub !== null && (this.parent._map.set(this.parentSub, this), this.left !== null && this.left.delete(t)), this.parentSub === null && this.countable && !this.deleted && (this.parent._length += this.length), jn(t.doc.store, this), this.content.integrate(t, this), Lr(t, this.parent, this.parentSub), (this.parent._item !== null && this.parent._item.deleted || this.parentSub !== null && this.right !== null) && this.delete(t);
+    } else new L(this.id, this.length).integrate(t, 0);
+  }
+  get next() {
+    let t = this.right;
+    for (; t !== null && t.deleted; ) t = t.right;
+    return t;
+  }
+  get prev() {
+    let t = this.left;
+    for (; t !== null && t.deleted; ) t = t.left;
+    return t;
+  }
+  get lastId() {
+    return this.length === 1 ? this.id : w(this.id.client, this.id.clock + this.length - 1);
+  }
+  mergeWith(t) {
+    if (this.constructor === t.constructor && It(t.origin, this.lastId) && this.right === t && It(this.rightOrigin, t.rightOrigin) && this.id.client === t.id.client && this.id.clock + this.length === t.id.clock && this.deleted === t.deleted && this.redone === null && t.redone === null && this.content.constructor === t.content.constructor && this.content.mergeWith(t.content)) {
+      const r = this.parent._searchMarker;
+      return r && r.forEach((n) => {
+        n.p === t && (n.p = this, !this.deleted && this.countable && (n.index -= this.length));
+      }), t.keep && (this.keep = !0), this.right = t.right, this.right !== null && (this.right.left = this), this.length += t.length, !0;
+    }
+    return !1;
+  }
+  delete(t) {
+    if (!this.deleted) {
+      const r = this.parent;
+      this.countable && this.parentSub === null && (r._length -= this.length), this.markDeleted(), jt(t.deleteSet, this.id.client, this.id.clock, this.length), Lr(t, r, this.parentSub), this.content.delete(t);
+    }
+  }
+  gc(t, r) {
+    if (!this.deleted) throw N();
+    this.content.gc(t), r ? Xl(t, this, new L(this.id, this.length)) : this.content = new cs(this.length);
+  }
+  write(t, r) {
+    const n = r > 0 ? w(this.id.client, this.id.clock + r - 1) : this.origin, s = this.rightOrigin, i = this.parentSub, l = this.content.getRef() & 31 | (n === null ? 0 : 128) | (s === null ? 0 : 64) | (i === null ? 0 : 32);
+    if (t.writeInfo(l), n !== null && t.writeLeftID(n), s !== null && t.writeRightID(s), n === null && s === null) {
+      const o = this.parent;
+      if (o._item !== void 0) {
+        const c = o._item;
+        if (c === null) {
+          const h = Fl(o);
+          t.writeParentInfo(!0), t.writeString(h);
+        } else
+          t.writeParentInfo(!1), t.writeLeftID(c.id);
+      } else o.constructor === String ? (t.writeParentInfo(!0), t.writeString(o)) : o.constructor === it ? (t.writeParentInfo(!1), t.writeLeftID(o)) : N();
+      i !== null && t.writeString(i);
+    }
+    this.content.write(t, r);
+  }
+}, gs = (e, t) => Xo[t & 31](e), Xo = [
+  () => {
+    N();
+  },
+  Do,
+  xo,
+  Eo,
+  No,
+  Io,
+  To,
+  Jo,
+  $o,
+  Ao,
+  () => {
+    N();
+  }
+], Go = 10, $ = class extends hr {
+  get deleted() {
+    return !0;
+  }
+  delete() {
+  }
+  mergeWith(e) {
+    return this.constructor !== e.constructor ? !1 : (this.length += e.length, !0);
+  }
+  integrate(e, t) {
+    N();
+  }
+  write(e, t) {
+    e.writeInfo(Go), v(e.restEncoder, this.length - t);
+  }
+  getMissing(e, t) {
+    return null;
+  }
+}, ps = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : {}, vs = "__ $YJS$ __";
+ps[vs] === !0 && console.error("Yjs was already imported. This breaks constructor checks and will lead to issues! - https://github.com/yjs/yjs/issues/438");
+ps[vs] = !0;
+export {
+  O as A,
+  rs as Array,
+  Ho as B,
+  Kt as C,
+  ye as D,
+  Pe as Doc,
+  vt as E,
+  Fr as F,
+  K as H,
+  B as I,
+  zo as L,
+  uc as M,
+  or as Map,
+  Vs as N,
+  rt as O,
+  V as P,
+  Br as R,
+  x as S,
+  R as T,
+  cr as Text,
+  J as U,
+  bs as V,
+  ht as _,
+  ml as a,
+  Wc as applyUpdate,
+  nt as b,
+  kc as c,
+  ot as d,
+  qc as encodeStateAsUpdate,
+  Zc as encodeStateVector,
+  Nt as f,
+  pi as g,
+  vc as h,
+  vn as i,
+  zs as j,
+  v as k,
+  bc as l,
+  wc as m,
+  Kc as n,
+  wn as o,
+  mc as p,
+  Gc as r,
+  bn as s,
+  zc as t,
+  _c as u,
+  wt as v,
+  Ws as w,
+  p as x,
+  lt as y,
+  Wo as z
+};