@inditextech/weave-store-websockets 0.1.1 → 0.2.0

package/dist/server.js

@@ -1,352 +1,1619 @@
-var G = Object.defineProperty;
-var H = (e, n, t) => n in e ? G(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
-var d = (e, n, t) => (H(e, typeof n != "symbol" ? n + "" : n, t), t);
-import { WebSocketServer as q } from "ws";
-import * as g from "yjs";
-import { D as Y, s as Q, w as A, e as Z, t as T, h as N, j as V, p as E, q as ee, r as te, z as ne, B as se, x as re, l as ae, k as oe, A as ie, g as ce } from "./awareness-C8fdGy2v.js";
-import { W as st, C as rt } from "./awareness-C8fdGy2v.js";
-import le from "http";
-var b = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
-function fe(e) {
-  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
-}
-var pe = "Expected a function", K = NaN, de = "[object Symbol]", ue = /^\s+|\s+$/g, ye = /^[-+]0x[0-9a-f]+$/i, ge = /^0b[01]+$/i, he = /^0o[0-7]+$/i, me = parseInt, we = typeof b == "object" && b && b.Object === Object && b, Se = typeof self == "object" && self && self.Object === Object && self, Ce = we || Se || Function("return this")(), Ae = Object.prototype, Te = Ae.toString, Ee = Math.max, ve = Math.min, B = function() {
-  return Ce.Date.now();
-};
-function Le(e, n, t) {
-  var r, s, i, a, o, p, l = 0, h = !1, f = !1, u = !0;
-  if (typeof e != "function")
-    throw new TypeError(pe);
-  n = D(n) || 0, R(t) && (h = !!t.leading, f = "maxWait" in t, i = f ? Ee(D(t.maxWait) || 0, n) : i, u = "trailing" in t ? !!t.trailing : u);
-  function O(c) {
-    var y = r, S = s;
-    return r = s = void 0, l = c, a = e.apply(S, y), a;
-  }
-  function X(c) {
-    return l = c, o = setTimeout(L, n), h ? O(c) : a;
-  }
-  function J(c) {
-    var y = c - p, S = c - l, x = n - y;
-    return f ? ve(x, i - S) : x;
-  }
-  function W(c) {
-    var y = c - p, S = c - l;
-    return p === void 0 || y >= n || y < 0 || f && S >= i;
-  }
-  function L() {
-    var c = B();
-    if (W(c))
-      return j(c);
-    o = setTimeout(L, J(c));
-  }
-  function j(c) {
-    return o = void 0, u && r ? O(c) : (r = s = void 0, a);
-  }
-  function $() {
-    o !== void 0 && clearTimeout(o), l = 0, r = p = s = o = void 0;
-  }
-  function z() {
-    return o === void 0 ? a : j(B());
-  }
-  function U() {
-    var c = B(), y = W(c);
-    if (r = arguments, s = this, p = c, y) {
-      if (o === void 0)
-        return X(p);
-      if (f)
-        return o = setTimeout(L, n), O(p);
-    }
-    return o === void 0 && (o = setTimeout(L, n)), a;
-  }
-  return U.cancel = $, U.flush = z, U;
-}
-function R(e) {
-  var n = typeof e;
-  return !!e && (n == "object" || n == "function");
-}
-function be(e) {
-  return !!e && typeof e == "object";
-}
-function Ie(e) {
-  return typeof e == "symbol" || be(e) && Te.call(e) == de;
-}
-function D(e) {
-  if (typeof e == "number")
-    return e;
-  if (Ie(e))
-    return K;
-  if (R(e)) {
-    var n = typeof e.valueOf == "function" ? e.valueOf() : e;
-    e = R(n) ? n + "" : n;
-  }
-  if (typeof e != "string")
-    return e === 0 ? e : +e;
-  e = e.replace(ue, "");
-  var t = ge.test(e);
-  return t || he.test(e) ? me(e.slice(2), t ? 2 : 8) : ye.test(e) ? K : +e;
-}
-var _e = Le;
-const Oe = /* @__PURE__ */ fe(_e), M = process.env.CALLBACK_URL ? new URL(process.env.CALLBACK_URL) : null, Ue = Y(
-  process.env.CALLBACK_TIMEOUT || "5000"
-), P = process.env.CALLBACK_OBJECTS ? JSON.parse(process.env.CALLBACK_OBJECTS) : {}, Be = !!M, Re = (e, n, t) => {
-  const s = {
-    room: t.name,
-    data: {}
-  };
-  Object.keys(P).forEach((a) => {
-    const o = P[a];
-    s.data[a] = {
-      type: o,
-      content: ke(a, o, t).toJSON()
-    };
-  }), M && Me(M, Ue, s);
-}, Me = (e, n, t) => {
-  t = JSON.stringify(t);
-  const r = {
-    hostname: e.hostname,
-    port: e.port,
-    path: e.pathname,
-    timeout: n,
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(t)
-    }
-  }, s = le.request(r);
-  s.on("timeout", () => {
-    console.warn("Callback request timed out."), s.abort();
-  }), s.on("error", (i) => {
-    console.error("Callback request error.", i), s.abort();
-  }), s.write(t), s.end();
-}, ke = (e, n, t) => {
-  switch (n) {
-    case "Array":
-      return t.getArray(e);
-    case "Map":
-      return t.getMap(e);
-    case "Text":
-      return t.getText(e);
-    case "XmlFragment":
-      return t.getXmlFragment(e);
-    case "XmlElement":
-      return t.getXmlElement(e);
-    default:
-      return {};
-  }
-};
-let m;
-const We = parseInt(
-  process.env.CALLBACK_DEBOUNCE_WAIT || "2000"
-), je = parseInt(
-  process.env.CALLBACK_DEBOUNCE_MAXWAIT || "10000"
-), xe = 0, Ke = 1, De = process.env.GC !== "false" && process.env.GC !== "0", F = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), _ = 0, k = 1, Pe = (e, n, t) => {
-  const r = E();
-  A(r, _), ce(r, e);
-  const s = T(r);
-  t.conns.forEach((i, a) => v(t, a, s));
-};
-let Fe = () => Promise.resolve();
-class Ne extends g.Doc {
-  constructor(t) {
-    super({ gc: De });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    d(this, "name");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    d(this, "conns");
-    d(this, "awareness");
-    d(this, "whenInitialized");
-    this.name = t, this.conns = /* @__PURE__ */ new Map(), this.awareness = new ie(this), this.awareness.setLocalState(null);
-    const r = ({
-      added: s,
-      updated: i,
-      removed: a
-    }, o) => {
-      const p = s.concat(i, a);
-      if (o !== null) {
-        const f = (
-          /** @type {Set<number>} */
-          this.conns.get(o)
-        );
-        f !== void 0 && (s.forEach((u) => {
-          f.add(u);
-        }), a.forEach((u) => {
-          f.delete(u);
-        }));
-      }
-      const l = E();
-      A(l, k), N(
-        l,
-        V(this.awareness, p)
-      );
-      const h = T(l);
-      this.conns.forEach((f, u) => {
-        v(this, u, h);
-      });
-    };
-    this.awareness.on("update", r), this.on("update", Pe), Be && this.on(
-      "update",
-      Oe(Re, We, {
-        maxWait: je
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      })
-    ), this.whenInitialized = Fe();
-  }
-}
-const Ve = (e, n, t = !0) => Q(F, e, async () => {
-  let r;
-  m && m.fetchRoom && (r = await m.fetchRoom(e));
-  const s = new Ne(e);
-  return s.gc = t, F.set(e, s), r ? g.applyUpdate(s, r) : n(s), await Ge(e, s), s;
-}), Xe = (e, n, t) => {
-  try {
-    const r = E(), s = ee(t);
-    switch (te(s)) {
-      case _:
-        A(r, _), re(s, r, n, e), ae(r) > 1 && v(n, e, T(r));
-        break;
-      case k: {
-        ne(
-          n.awareness,
-          se(s),
-          e
-        );
-        break;
-      }
-    }
-  } catch (r) {
-    console.error(r);
-  }
-}, w = (e, n) => {
-  if (e.conns.has(n)) {
-    const t = e.conns.get(n);
-    e.conns.delete(n), I.has(e.name) && clearInterval(I.get(e.name)), oe(
-      e.awareness,
-      Array.from(t),
-      null
-    );
-  }
-  n.close();
-}, v = (e, n, t) => {
-  n.readyState !== xe && n.readyState !== Ke && w(e, n);
-  try {
-    n.send(t, {}, (r) => {
-      r != null && w(e, n);
-    });
-  } catch {
-    w(e, n);
-  }
-}, Je = 3e4, $e = (e) => {
-  m = e;
-}, ze = (e, n) => async (t, r, { gc: s = !0 } = {}) => {
-  const i = e(r);
-  if (!i)
-    return;
-  t.binaryType = "arraybuffer";
-  const a = await Ve(i, n, s);
-  a.conns.set(t, /* @__PURE__ */ new Set()), t.on(
-    "message",
-    (l) => Xe(t, a, new Uint8Array(l))
-  );
-  let o = !0;
-  const p = setInterval(() => {
-    if (!o)
-      a.conns.has(t) && w(a, t), clearInterval(p);
-    else if (a.conns.has(t)) {
-      o = !1;
-      try {
-        t.ping();
-      } catch {
-        w(a, t), clearInterval(p);
-      }
-    }
-  }, Je);
-  t.on("close", () => {
-    w(a, t), clearInterval(p);
-  }), t.on("pong", () => {
-    o = !0;
-  });
-  {
-    const l = E();
-    A(l, _), Z(l, a), v(a, t, T(l));
-    const h = a.awareness.getStates();
-    if (h.size > 0) {
-      const f = E();
-      A(f, k), N(
-        f,
-        V(
-          a.awareness,
-          Array.from(h.keys())
-        )
-      ), v(a, t, T(f));
-    }
-  }
-};
-async function Ge(e, n) {
-  if (!I.has(e)) {
-    const t = async () => {
-      const s = g.encodeStateAsUpdate(n);
-      if (m && m.persistRoom)
-        try {
-          await m.persistRoom(e, s);
-        } catch (i) {
-          console.error(i);
-        }
-    };
-    t();
-    const r = setInterval(
-      t,
-      parseInt(process.env.WEAVE_WEBSOCKETS_STATE_SYNC_FREQUENCY_SEG ?? "10") * 1e3
-    );
-    I.set(e, r);
-  }
-}
-const C = function(e) {
-  const n = new g.Map();
-  n.set("key", e), n.set("type", "layer");
-  const t = new g.Map();
-  return t.set("id", e), t.set("nodeType", "layer"), t.set("children", new g.Array()), n.set("props", t), n;
-};
-function He(e) {
-  const n = new g.Array();
-  n.insert(0, [
-    C("gridLayer"),
-    C("mainLayer"),
-    C("selectionLayer"),
-    C("usersPointersLayer"),
-    C("utilityLayer")
-  ]);
-  const t = new g.Map();
-  t.set("id", "stage"), t.set("children", n), e.getMap("weave").set("key", "stage"), e.getMap("weave").set("type", "stage"), e.getMap("weave").set("props", t);
+import { WEAVE_STORE_WEBSOCKETS, WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS } from "./types-Cq7de9Ah.js";
+import http from "http";
+import https from "https";
+import { WebSocketServer } from "ws";
+import * as Y$2 from "yjs";
+import * as Y$1 from "yjs";
+import * as Y from "yjs";
+import "node:http";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from$1, except, desc) => {
+	if (from$1 && typeof from$1 === "object" || typeof from$1 === "function") for (var keys$1 = __getOwnPropNames(from$1), i = 0, n = keys$1.length, key; i < n; i++) {
+		key = keys$1[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from$1[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from$1, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region ../../node_modules/lib0/math.js
+/**
+* Common Math expressions.
+*
+* @module math
+*/
+const floor = Math.floor;
+/**
+* @function
+* @param {number} a
+* @param {number} b
+* @return {number} The smaller element of a and b
+*/
+const min = (a, b) => a < b ? a : b;
+/**
+* @function
+* @param {number} a
+* @param {number} b
+* @return {number} The bigger element of a and b
+*/
+const max = (a, b) => a > b ? a : b;
+const isNaN$1 = Number.isNaN;
+
+//#endregion
+//#region ../../node_modules/lib0/binary.js
+const BIT8 = 128;
+const BIT18 = 1 << 17;
+const BIT19 = 1 << 18;
+const BIT20 = 1 << 19;
+const BIT21 = 1 << 20;
+const BIT22 = 1 << 21;
+const BIT23 = 1 << 22;
+const BIT24 = 1 << 23;
+const BIT25 = 1 << 24;
+const BIT26 = 1 << 25;
+const BIT27 = 1 << 26;
+const BIT28 = 1 << 27;
+const BIT29 = 1 << 28;
+const BIT30 = 1 << 29;
+const BIT31 = 1 << 30;
+const BIT32 = 1 << 31;
+const BITS7 = 127;
+const BITS17 = BIT18 - 1;
+const BITS18 = BIT19 - 1;
+const BITS19 = BIT20 - 1;
+const BITS20 = BIT21 - 1;
+const BITS21 = BIT22 - 1;
+const BITS22 = BIT23 - 1;
+const BITS23 = BIT24 - 1;
+const BITS24 = BIT25 - 1;
+const BITS25 = BIT26 - 1;
+const BITS26 = BIT27 - 1;
+const BITS27 = BIT28 - 1;
+const BITS28 = BIT29 - 1;
+const BITS29 = BIT30 - 1;
+const BITS30 = BIT31 - 1;
+/**
+* @type {number}
+*/
+const BITS31 = 2147483647;
+/**
+* @type {number}
+*/
+const BITS32 = 4294967295;
+
+//#endregion
+//#region ../../node_modules/lib0/number.js
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
+const LOWEST_INT32 = 1 << 31;
+const HIGHEST_INT32 = BITS31;
+const HIGHEST_UINT32 = BITS32;
+/* c8 ignore next */
+const isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
+const isNaN = Number.isNaN;
+const parseInt$1 = Number.parseInt;
+
+//#endregion
+//#region ../../node_modules/lib0/set.js
+/**
+* Utility module to work with sets.
+*
+* @module set
+*/
+const create$2 = () => new Set();
+
+//#endregion
+//#region ../../node_modules/lib0/array.js
+/**
+* Transforms something array-like to an actual Array.
+*
+* @function
+* @template T
+* @param {ArrayLike<T>|Iterable<T>} arraylike
+* @return {T}
+*/
+const from = Array.from;
+const isArray$1 = Array.isArray;
+
+//#endregion
+//#region ../../node_modules/lib0/string.js
+/**
+* Utility module to work with strings.
+*
+* @module string
+*/
+const fromCharCode = String.fromCharCode;
+const fromCodePoint = String.fromCodePoint;
+/**
+* The largest utf16 character.
+* Corresponds to Uint8Array([255, 255]) or charcodeof(2x2^8)
+*/
+const MAX_UTF16_CHARACTER = fromCharCode(65535);
+/**
+* @param {string} str
+* @return {Uint8Array}
+*/
+const _encodeUtf8Polyfill = (str) => {
+	const encodedString = unescape(encodeURIComponent(str));
+	const len = encodedString.length;
+	const buf = new Uint8Array(len);
+	for (let i = 0; i < len; i++) buf[i] = encodedString.codePointAt(i);
+	return buf;
+};
+/* c8 ignore next */
+const utf8TextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+/**
+* @param {string} str
+* @return {Uint8Array}
+*/
+const _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
+/**
+* @param {string} str
+* @return {Uint8Array}
+*/
+/* c8 ignore next */
+const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+/* c8 ignore next */
+let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+/* c8 ignore start */
+if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1)
+ /* c8 ignore next */
+utf8TextDecoder = null;
+
+//#endregion
+//#region ../../node_modules/lib0/encoding.js
+/**
+* A BinaryEncoder handles the encoding to an Uint8Array.
+*/
+var Encoder = class {
+	constructor() {
+		this.cpos = 0;
+		this.cbuf = new Uint8Array(100);
+		/**
+		* @type {Array<Uint8Array>}
+		*/
+		this.bufs = [];
+	}
+};
+/**
+* @function
+* @return {Encoder}
+*/
+const createEncoder = () => new Encoder();
+/**
+* The current length of the encoded data.
+*
+* @function
+* @param {Encoder} encoder
+* @return {number}
+*/
+const length$1 = (encoder) => {
+	let len = encoder.cpos;
+	for (let i = 0; i < encoder.bufs.length; i++) len += encoder.bufs[i].length;
+	return len;
+};
+/**
+* Transform to Uint8Array.
+*
+* @function
+* @param {Encoder} encoder
+* @return {Uint8Array} The created ArrayBuffer.
+*/
+const toUint8Array = (encoder) => {
+	const uint8arr = new Uint8Array(length$1(encoder));
+	let curPos = 0;
+	for (let i = 0; i < encoder.bufs.length; i++) {
+		const d = encoder.bufs[i];
+		uint8arr.set(d, curPos);
+		curPos += d.length;
+	}
+	uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+	return uint8arr;
+};
+/**
+* Write one byte to the encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {number} num The byte that is to be encoded.
+*/
+const write = (encoder, num) => {
+	const bufferLen = encoder.cbuf.length;
+	if (encoder.cpos === bufferLen) {
+		encoder.bufs.push(encoder.cbuf);
+		encoder.cbuf = new Uint8Array(bufferLen * 2);
+		encoder.cpos = 0;
+	}
+	encoder.cbuf[encoder.cpos++] = num;
+};
+/**
+* Write a variable length unsigned integer. Max encodable integer is 2^53.
+*
+* @function
+* @param {Encoder} encoder
+* @param {number} num The number that is to be encoded.
+*/
+const writeVarUint = (encoder, num) => {
+	while (num > BITS7) {
+		write(encoder, BIT8 | BITS7 & num);
+		num = floor(num / 128);
+	}
+	write(encoder, BITS7 & num);
+};
+/**
+* A cache to store strings temporarily
+*/
+const _strBuffer = new Uint8Array(3e4);
+const _maxStrBSize = _strBuffer.length / 3;
+/**
+* Write a variable length string.
+*
+* @function
+* @param {Encoder} encoder
+* @param {String} str The string that is to be encoded.
+*/
+const _writeVarStringNative = (encoder, str) => {
+	if (str.length < _maxStrBSize) {
+		/* c8 ignore next */
+		const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+		writeVarUint(encoder, written);
+		for (let i = 0; i < written; i++) write(encoder, _strBuffer[i]);
+	} else writeVarUint8Array(encoder, encodeUtf8(str));
+};
+/**
+* Write a variable length string.
+*
+* @function
+* @param {Encoder} encoder
+* @param {String} str The string that is to be encoded.
+*/
+const _writeVarStringPolyfill = (encoder, str) => {
+	const encodedString = unescape(encodeURIComponent(str));
+	const len = encodedString.length;
+	writeVarUint(encoder, len);
+	for (let i = 0; i < len; i++) write(
+		encoder,
+		/** @type {number} */
+		encodedString.codePointAt(i)
+);
+};
+/**
+* Write a variable length string.
+*
+* @function
+* @param {Encoder} encoder
+* @param {String} str The string that is to be encoded.
+*/
+/* c8 ignore next */
+const writeVarString = utf8TextEncoder && utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
+/**
+* Append fixed-length Uint8Array to the encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {Uint8Array} uint8Array
+*/
+const writeUint8Array = (encoder, uint8Array) => {
+	const bufferLen = encoder.cbuf.length;
+	const cpos = encoder.cpos;
+	const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+	const rightCopyLen = uint8Array.length - leftCopyLen;
+	encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+	encoder.cpos += leftCopyLen;
+	if (rightCopyLen > 0) {
+		encoder.bufs.push(encoder.cbuf);
+		encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+		encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+		encoder.cpos = rightCopyLen;
+	}
+};
+/**
+* Append an Uint8Array to Encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {Uint8Array} uint8Array
+*/
+const writeVarUint8Array = (encoder, uint8Array) => {
+	writeVarUint(encoder, uint8Array.byteLength);
+	writeUint8Array(encoder, uint8Array);
+};
+const floatTestBed = new DataView(new ArrayBuffer(4));
+
+//#endregion
+//#region ../../node_modules/lib0/error.js
+/**
+* Error helpers.
+*
+* @module error
+*/
+/**
+* @param {string} s
+* @return {Error}
+*/
+/* c8 ignore next */
+const create$1 = (s) => new Error(s);
+
+//#endregion
+//#region ../../node_modules/lib0/decoding.js
+const errorUnexpectedEndOfArray = create$1("Unexpected end of array");
+const errorIntegerOutOfRange = create$1("Integer out of Range");
+/**
+* A Decoder handles the decoding of an Uint8Array.
+*/
+var Decoder = class {
+	/**
+	* @param {Uint8Array} uint8Array Binary data to decode
+	*/
+	constructor(uint8Array) {
+		/**
+		* Decoding target.
+		*
+		* @type {Uint8Array}
+		*/
+		this.arr = uint8Array;
+		/**
+		* Current decoding position.
+		*
+		* @type {number}
+		*/
+		this.pos = 0;
+	}
+};
+/**
+* @function
+* @param {Uint8Array} uint8Array
+* @return {Decoder}
+*/
+const createDecoder = (uint8Array) => new Decoder(uint8Array);
+/**
+* Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+*
+* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+*
+* @function
+* @param {Decoder} decoder The decoder instance
+* @param {number} len The length of bytes to read
+* @return {Uint8Array}
+*/
+const readUint8Array = (decoder, len) => {
+	const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+	decoder.pos += len;
+	return view;
+};
+/**
+* Read variable length Uint8Array.
+*
+* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+*
+* @function
+* @param {Decoder} decoder
+* @return {Uint8Array}
+*/
+const readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
+/**
+* Read one byte as unsigned integer.
+* @function
+* @param {Decoder} decoder The decoder instance
+* @return {number} Unsigned 8-bit integer
+*/
+const readUint8 = (decoder) => decoder.arr[decoder.pos++];
+/**
+* Read unsigned integer (32bit) with variable length.
+* 1/8th of the storage is used as encoding overhead.
+*  * numbers < 2^7 is stored in one bytlength
+*  * numbers < 2^14 is stored in two bylength
+*
+* @function
+* @param {Decoder} decoder
+* @return {number} An unsigned integer.length
+*/
+const readVarUint = (decoder) => {
+	let num = 0;
+	let mult = 1;
+	const len = decoder.arr.length;
+	while (decoder.pos < len) {
+		const r = decoder.arr[decoder.pos++];
+		num = num + (r & BITS7) * mult;
+		mult *= 128;
+		if (r < BIT8) return num;
+		/* c8 ignore start */
+		if (num > MAX_SAFE_INTEGER) throw errorIntegerOutOfRange;
+	}
+	throw errorUnexpectedEndOfArray;
+};
+/**
+* We don't test this function anymore as we use native decoding/encoding by default now.
+* Better not modify this anymore..
+*
+* Transforming utf8 to a string is pretty expensive. The code performs 10x better
+* when String.fromCodePoint is fed with all characters as arguments.
+* But most environments have a maximum number of arguments per functions.
+* For effiency reasons we apply a maximum of 10000 characters at once.
+*
+* @function
+* @param {Decoder} decoder
+* @return {String} The read String.
+*/
+/* c8 ignore start */
+const _readVarStringPolyfill = (decoder) => {
+	let remainingLen = readVarUint(decoder);
+	if (remainingLen === 0) return "";
+	else {
+		let encodedString = String.fromCodePoint(readUint8(decoder));
+		if (--remainingLen < 100) while (remainingLen--) encodedString += String.fromCodePoint(readUint8(decoder));
+		else while (remainingLen > 0) {
+			const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+			const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
+			decoder.pos += nextLen;
+			encodedString += String.fromCodePoint.apply(
+				null,
+				/** @type {any} */
+				bytes
+);
+			remainingLen -= nextLen;
+		}
+		return decodeURIComponent(escape(encodedString));
+	}
+};
+/* c8 ignore stop */
+/**
+* @function
+* @param {Decoder} decoder
+* @return {String} The read String
+*/
+const _readVarStringNative = (decoder) => utf8TextDecoder.decode(readVarUint8Array(decoder));
+/**
+* Read string of variable length
+* * varUint is used to store the length of the string
+*
+* @function
+* @param {Decoder} decoder
+* @return {String} The read String
+*
+*/
+/* c8 ignore next */
+const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
+
+//#endregion
+//#region ../../node_modules/y-protocols/sync.js
+/**
+* @typedef {Map<number, number>} StateMap
+*/
+/**
+* Core Yjs defines two message types:
+* • YjsSyncStep1: Includes the State Set of the sending client. When received, the client should reply with YjsSyncStep2.
+* • YjsSyncStep2: Includes all missing structs and the complete delete set. When received, the client is assured that it
+*   received all information from the remote client.
+*
+* In a peer-to-peer network, you may want to introduce a SyncDone message type. Both parties should initiate the connection
+* with SyncStep1. When a client received SyncStep2, it should reply with SyncDone. When the local client received both
+* SyncStep2 and SyncDone, it is assured that it is synced to the remote client.
+*
+* In a client-server model, you want to handle this differently: The client should initiate the connection with SyncStep1.
+* When the server receives SyncStep1, it should reply with SyncStep2 immediately followed by SyncStep1. The client replies
+* with SyncStep2 when it receives SyncStep1. Optionally the server may send a SyncDone after it received SyncStep2, so the
+* client knows that the sync is finished.  There are two reasons for this more elaborated sync model: 1. This protocol can
+* easily be implemented on top of http and websockets. 2. The server should only reply to requests, and not initiate them.
+* Therefore it is necessary that the client initiates the sync.
+*
+* Construction of a message:
+* [messageType : varUint, message definition..]
+*
+* Note: A message does not include information about the room name. This must to be handled by the upper layer protocol!
+*
+* stringify[messageType] stringifies a message definition (messageType is already read from the bufffer)
+*/
+const messageYjsSyncStep1 = 0;
+const messageYjsSyncStep2 = 1;
+const messageYjsUpdate = 2;
+/**
+* Create a sync step 1 message based on the state of the current shared document.
+*
+* @param {encoding.Encoder} encoder
+* @param {Y.Doc} doc
+*/
+const writeSyncStep1 = (encoder, doc) => {
+	writeVarUint(encoder, messageYjsSyncStep1);
+	const sv = Y$2.encodeStateVector(doc);
+	writeVarUint8Array(encoder, sv);
+};
+/**
+* @param {encoding.Encoder} encoder
+* @param {Y.Doc} doc
+* @param {Uint8Array} [encodedStateVector]
+*/
+const writeSyncStep2 = (encoder, doc, encodedStateVector) => {
+	writeVarUint(encoder, messageYjsSyncStep2);
+	writeVarUint8Array(encoder, Y$2.encodeStateAsUpdate(doc, encodedStateVector));
+};
+/**
+* Read SyncStep1 message and reply with SyncStep2.
+*
+* @param {decoding.Decoder} decoder The reply to the received message
+* @param {encoding.Encoder} encoder The received message
+* @param {Y.Doc} doc
+*/
+const readSyncStep1 = (decoder, encoder, doc) => writeSyncStep2(encoder, doc, readVarUint8Array(decoder));
+/**
+* Read and apply Structs and then DeleteStore to a y instance.
+*
+* @param {decoding.Decoder} decoder
+* @param {Y.Doc} doc
+* @param {any} transactionOrigin
+*/
+const readSyncStep2 = (decoder, doc, transactionOrigin) => {
+	try {
+		Y$2.applyUpdate(doc, readVarUint8Array(decoder), transactionOrigin);
+	} catch (error) {
+		console.error("Caught error while handling a Yjs update", error);
+	}
+};
+/**
+* @param {encoding.Encoder} encoder
+* @param {Uint8Array} update
+*/
+const writeUpdate = (encoder, update) => {
+	writeVarUint(encoder, messageYjsUpdate);
+	writeVarUint8Array(encoder, update);
+};
+/**
+* Read and apply Structs and then DeleteStore to a y instance.
+*
+* @param {decoding.Decoder} decoder
+* @param {Y.Doc} doc
+* @param {any} transactionOrigin
+*/
+const readUpdate = readSyncStep2;
+/**
+* @param {decoding.Decoder} decoder A message received from another client
+* @param {encoding.Encoder} encoder The reply message. Does not need to be sent if empty.
+* @param {Y.Doc} doc
+* @param {any} transactionOrigin
+*/
+const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
+	const messageType = readVarUint(decoder);
+	switch (messageType) {
+		case messageYjsSyncStep1:
+			readSyncStep1(decoder, encoder, doc);
+			break;
+		case messageYjsSyncStep2:
+			readSyncStep2(decoder, doc, transactionOrigin);
+			break;
+		case messageYjsUpdate:
+			readUpdate(decoder, doc, transactionOrigin);
+			break;
+		default: throw new Error("Unknown message type");
+	}
+	return messageType;
+};
+
+//#endregion
+//#region ../../node_modules/lib0/time.js
+/**
+* Return current unix time.
+*
+* @return {number}
+*/
+const getUnixTime = Date.now;
+
+//#endregion
+//#region ../../node_modules/lib0/map.js
+/**
+* Utility module to work with key-value stores.
+*
+* @module map
+*/
+/**
+* Creates a new Map instance.
+*
+* @function
+* @return {Map<any, any>}
+*
+* @function
+*/
+const create = () => new Map();
+/**
+* Get map property. Create T if property is undefined and set T on map.
+*
+* ```js
+* const listeners = map.setIfUndefined(events, 'eventName', set.create)
+* listeners.add(listener)
+* ```
+*
+* @function
+* @template {Map<any, any>} MAP
+* @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
+* @param {MAP} map
+* @param {MAP extends Map<infer K,any> ? K : unknown} key
+* @param {CF} createT
+* @return {ReturnType<CF>}
+*/
+const setIfUndefined = (map, key, createT) => {
+	let set = map.get(key);
+	if (set === void 0) map.set(key, set = createT());
+	return set;
+};
+
+//#endregion
+//#region ../../node_modules/lib0/observable.js
+/* c8 ignore start */
+/**
+* Handles named events.
+*
+* @deprecated
+* @template N
+*/
+var Observable = class {
+	constructor() {
+		/**
+		* Some desc.
+		* @type {Map<N, any>}
+		*/
+		this._observers = create();
+	}
+	/**
+	* @param {N} name
+	* @param {function} f
+	*/
+	on(name, f) {
+		setIfUndefined(this._observers, name, create$2).add(f);
+	}
+	/**
+	* @param {N} name
+	* @param {function} f
+	*/
+	once(name, f) {
+		/**
+		* @param  {...any} args
+		*/
+		const _f = (...args) => {
+			this.off(name, _f);
+			f(...args);
+		};
+		this.on(name, _f);
+	}
+	/**
+	* @param {N} name
+	* @param {function} f
+	*/
+	off(name, f) {
+		const observers = this._observers.get(name);
+		if (observers !== void 0) {
+			observers.delete(f);
+			if (observers.size === 0) this._observers.delete(name);
+		}
+	}
+	/**
+	* Emit a named event. All registered event listeners that listen to the
+	* specified name will receive the event.
+	*
+	* @todo This should catch exceptions
+	*
+	* @param {N} name The event name.
+	* @param {Array<any>} args The arguments that are applied to the event listener.
+	*/
+	emit(name, args) {
+		return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args));
+	}
+	destroy() {
+		this._observers = create();
+	}
+};
+/* c8 ignore end */
+
+//#endregion
+//#region ../../node_modules/lib0/object.js
+/**
+* @param {Object<string,any>} obj
+*/
+const keys = Object.keys;
+/**
+* @deprecated use object.size instead
+* @param {Object<string,any>} obj
+* @return {number}
+*/
+const length = (obj) => keys(obj).length;
+/**
+* Calls `Object.prototype.hasOwnProperty`.
+*
+* @param {any} obj
+* @param {string|symbol} key
+* @return {boolean}
+*/
+const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+//#endregion
+//#region ../../node_modules/lib0/traits.js
+const EqualityTraitSymbol = Symbol("Equality");
+/**
+* @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
+*/
+
+//#endregion
+//#region ../../node_modules/lib0/function.js
+/* c8 ignore start */
+/**
+* @param {any} a
+* @param {any} b
+* @return {boolean}
+*/
+const equalityDeep = (a, b) => {
+	if (a === b) return true;
+	if (a == null || b == null || a.constructor !== b.constructor) return false;
+	if (a[EqualityTraitSymbol] != null) return a[EqualityTraitSymbol](b);
+	switch (a.constructor) {
+		case ArrayBuffer:
+			a = new Uint8Array(a);
+			b = new Uint8Array(b);
+		case Uint8Array: {
+			if (a.byteLength !== b.byteLength) return false;
+			for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+			break;
+		}
+		case Set: {
+			if (a.size !== b.size) return false;
+			for (const value of a) if (!b.has(value)) return false;
+			break;
+		}
+		case Map: {
+			if (a.size !== b.size) return false;
+			for (const key of a.keys()) if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) return false;
+			break;
+		}
+		case Object:
+			if (length(a) !== length(b)) return false;
+			for (const key in a) if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) return false;
+			break;
+		case Array:
+			if (a.length !== b.length) return false;
+			for (let i = 0; i < a.length; i++) if (!equalityDeep(a[i], b[i])) return false;
+			break;
+		default: return false;
+	}
+	return true;
+};
+/* c8 ignore stop */
+const isArray = isArray$1;
+
+//#endregion
+//#region ../../node_modules/y-protocols/awareness.js
+const outdatedTimeout = 3e4;
+/**
+* @typedef {Object} MetaClientState
+* @property {number} MetaClientState.clock
+* @property {number} MetaClientState.lastUpdated unix timestamp
+*/
+/**
+* The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information
+* (cursor, username, status, ..). Each client can update its own local state and listen to state changes of
+* remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.
+*
+* Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override
+* its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is
+* applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that
+* a remote client is offline, it may propagate a message with
+* `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a
+* message is received, and the known clock of that client equals the received clock, it will override the state with `null`.
+*
+* Before a client disconnects, it should propagate a `null` state with an updated clock.
+*
+* Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.
+*
+* @extends {Observable<string>}
+*/
+var Awareness = class extends Observable {
+	/**
+	* @param {Y.Doc} doc
+	*/
+	constructor(doc) {
+		super();
+		this.doc = doc;
+		/**
+		* @type {number}
+		*/
+		this.clientID = doc.clientID;
+		/**
+		* Maps from client id to client state
+		* @type {Map<number, Object<string, any>>}
+		*/
+		this.states = new Map();
+		/**
+		* @type {Map<number, MetaClientState>}
+		*/
+		this.meta = new Map();
+		this._checkInterval = setInterval(() => {
+			const now$1 = getUnixTime();
+			if (this.getLocalState() !== null && outdatedTimeout / 2 <= now$1 - this.meta.get(this.clientID).lastUpdated) this.setLocalState(this.getLocalState());
+			/**
+			* @type {Array<number>}
+			*/
+			const remove = [];
+			this.meta.forEach((meta, clientid) => {
+				if (clientid !== this.clientID && outdatedTimeout <= now$1 - meta.lastUpdated && this.states.has(clientid)) remove.push(clientid);
+			});
+			if (remove.length > 0) removeAwarenessStates(this, remove, "timeout");
+		}, floor(outdatedTimeout / 10));
+		doc.on("destroy", () => {
+			this.destroy();
+		});
+		this.setLocalState({});
+	}
+	destroy() {
+		this.emit("destroy", [this]);
+		this.setLocalState(null);
+		super.destroy();
+		clearInterval(this._checkInterval);
+	}
+	/**
+	* @return {Object<string,any>|null}
+	*/
+	getLocalState() {
+		return this.states.get(this.clientID) || null;
+	}
+	/**
+	* @param {Object<string,any>|null} state
+	*/
+	setLocalState(state) {
+		const clientID = this.clientID;
+		const currLocalMeta = this.meta.get(clientID);
+		const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
+		const prevState = this.states.get(clientID);
+		if (state === null) this.states.delete(clientID);
+		else this.states.set(clientID, state);
+		this.meta.set(clientID, {
+			clock,
+			lastUpdated: getUnixTime()
+		});
+		const added = [];
+		const updated = [];
+		const filteredUpdated = [];
+		const removed = [];
+		if (state === null) removed.push(clientID);
+		else if (prevState == null) {
+			if (state != null) added.push(clientID);
+		} else {
+			updated.push(clientID);
+			if (!equalityDeep(prevState, state)) filteredUpdated.push(clientID);
+		}
+		if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) this.emit("change", [{
+			added,
+			updated: filteredUpdated,
+			removed
+		}, "local"]);
+		this.emit("update", [{
+			added,
+			updated,
+			removed
+		}, "local"]);
+	}
+	/**
+	* @param {string} field
+	* @param {any} value
+	*/
+	setLocalStateField(field, value) {
+		const state = this.getLocalState();
+		if (state !== null) this.setLocalState({
+			...state,
+			[field]: value
+		});
+	}
+	/**
+	* @return {Map<number,Object<string,any>>}
+	*/
+	getStates() {
+		return this.states;
+	}
+};
+/**
+* Mark (remote) clients as inactive and remove them from the list of active peers.
+* This change will be propagated to remote clients.
+*
+* @param {Awareness} awareness
+* @param {Array<number>} clients
+* @param {any} origin
+*/
+const removeAwarenessStates = (awareness, clients, origin) => {
+	const removed = [];
+	for (let i = 0; i < clients.length; i++) {
+		const clientID = clients[i];
+		if (awareness.states.has(clientID)) {
+			awareness.states.delete(clientID);
+			if (clientID === awareness.clientID) {
+				const curMeta = awareness.meta.get(clientID);
+				awareness.meta.set(clientID, {
+					clock: curMeta.clock + 1,
+					lastUpdated: getUnixTime()
+				});
+			}
+			removed.push(clientID);
+		}
+	}
+	if (removed.length > 0) {
+		awareness.emit("change", [{
+			added: [],
+			updated: [],
+			removed
+		}, origin]);
+		awareness.emit("update", [{
+			added: [],
+			updated: [],
+			removed
+		}, origin]);
+	}
+};
+/**
+* @param {Awareness} awareness
+* @param {Array<number>} clients
+* @return {Uint8Array}
+*/
+const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
+	const len = clients.length;
+	const encoder = createEncoder();
+	writeVarUint(encoder, len);
+	for (let i = 0; i < len; i++) {
+		const clientID = clients[i];
+		const state = states.get(clientID) || null;
+		const clock = awareness.meta.get(clientID).clock;
+		writeVarUint(encoder, clientID);
+		writeVarUint(encoder, clock);
+		writeVarString(encoder, JSON.stringify(state));
+	}
+	return toUint8Array(encoder);
+};
+/**
+* @param {Awareness} awareness
+* @param {Uint8Array} update
+* @param {any} origin This will be added to the emitted change event
+*/
+const applyAwarenessUpdate = (awareness, update, origin) => {
+	const decoder = createDecoder(update);
+	const timestamp = getUnixTime();
+	const added = [];
+	const updated = [];
+	const filteredUpdated = [];
+	const removed = [];
+	const len = readVarUint(decoder);
+	for (let i = 0; i < len; i++) {
+		const clientID = readVarUint(decoder);
+		let clock = readVarUint(decoder);
+		const state = JSON.parse(readVarString(decoder));
+		const clientMeta = awareness.meta.get(clientID);
+		const prevState = awareness.states.get(clientID);
+		const currClock = clientMeta === void 0 ? 0 : clientMeta.clock;
+		if (currClock < clock || currClock === clock && state === null && awareness.states.has(clientID)) {
+			if (state === null) if (clientID === awareness.clientID && awareness.getLocalState() != null) clock++;
+			else awareness.states.delete(clientID);
+			else awareness.states.set(clientID, state);
+			awareness.meta.set(clientID, {
+				clock,
+				lastUpdated: timestamp
+			});
+			if (clientMeta === void 0 && state !== null) added.push(clientID);
+			else if (clientMeta !== void 0 && state === null) removed.push(clientID);
+			else if (state !== null) {
+				if (!equalityDeep(state, prevState)) filteredUpdated.push(clientID);
+				updated.push(clientID);
+			}
+		}
+	}
+	if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) awareness.emit("change", [{
+		added,
+		updated: filteredUpdated,
+		removed
+	}, origin]);
+	if (added.length > 0 || updated.length > 0 || removed.length > 0) awareness.emit("update", [{
+		added,
+		updated,
+		removed
+	}, origin]);
+};
+
+//#endregion
+//#region ../../node_modules/lodash.debounce/index.js
+var require_lodash = __commonJS({ "../../node_modules/lodash.debounce/index.js"(exports, module) {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as the `TypeError` message for "Functions" methods. */
+	var FUNC_ERROR_TEXT = "Expected a function";
+	/** Used as references for various `Number` constants. */
+	var NAN = NaN;
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/** Used to match leading and trailing whitespace. */
+	var reTrim = /^\s+|\s+$/g;
+	/** Used to detect bad signed hexadecimal string values. */
+	var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+	/** Used to detect binary string values. */
+	var reIsBinary = /^0b[01]+$/i;
+	/** Used to detect octal string values. */
+	var reIsOctal = /^0o[0-7]+$/i;
+	/** Built-in method references without a dependency on `root`. */
+	var freeParseInt = parseInt;
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function("return this")();
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString = objectProto.toString;
+	var nativeMax = Math.max, nativeMin = Math.min;
+	/**
+	* Gets the timestamp of the number of milliseconds that have elapsed since
+	* the Unix epoch (1 January 1970 00:00:00 UTC).
+	*
+	* @static
+	* @memberOf _
+	* @since 2.4.0
+	* @category Date
+	* @returns {number} Returns the timestamp.
+	* @example
+	*
+	* _.defer(function(stamp) {
+	*   console.log(_.now() - stamp);
+	* }, _.now());
+	* // => Logs the number of milliseconds it took for the deferred invocation.
+	*/
+	var now = function() {
+		return root.Date.now();
+	};
+	/**
+	* Creates a debounced function that delays invoking `func` until after `wait`
+	* milliseconds have elapsed since the last time the debounced function was
+	* invoked. The debounced function comes with a `cancel` method to cancel
+	* delayed `func` invocations and a `flush` method to immediately invoke them.
+	* Provide `options` to indicate whether `func` should be invoked on the
+	* leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+	* with the last arguments provided to the debounced function. Subsequent
+	* calls to the debounced function return the result of the last `func`
+	* invocation.
+	*
+	* **Note:** If `leading` and `trailing` options are `true`, `func` is
+	* invoked on the trailing edge of the timeout only if the debounced function
+	* is invoked more than once during the `wait` timeout.
+	*
+	* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+	* until to the next tick, similar to `setTimeout` with a timeout of `0`.
+	*
+	* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+	* for details over the differences between `_.debounce` and `_.throttle`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Function
+	* @param {Function} func The function to debounce.
+	* @param {number} [wait=0] The number of milliseconds to delay.
+	* @param {Object} [options={}] The options object.
+	* @param {boolean} [options.leading=false]
+	*  Specify invoking on the leading edge of the timeout.
+	* @param {number} [options.maxWait]
+	*  The maximum time `func` is allowed to be delayed before it's invoked.
+	* @param {boolean} [options.trailing=true]
+	*  Specify invoking on the trailing edge of the timeout.
+	* @returns {Function} Returns the new debounced function.
+	* @example
+	*
+	* // Avoid costly calculations while the window size is in flux.
+	* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+	*
+	* // Invoke `sendMail` when clicked, debouncing subsequent calls.
+	* jQuery(element).on('click', _.debounce(sendMail, 300, {
+	*   'leading': true,
+	*   'trailing': false
+	* }));
+	*
+	* // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+	* var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+	* var source = new EventSource('/stream');
+	* jQuery(source).on('message', debounced);
+	*
+	* // Cancel the trailing debounced invocation.
+	* jQuery(window).on('popstate', debounced.cancel);
+	*/
+	function debounce(func, wait, options) {
+		var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+		if (typeof func != "function") throw new TypeError(FUNC_ERROR_TEXT);
+		wait = toNumber(wait) || 0;
+		if (isObject(options)) {
+			leading = !!options.leading;
+			maxing = "maxWait" in options;
+			maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+			trailing = "trailing" in options ? !!options.trailing : trailing;
+		}
+		function invokeFunc(time) {
+			var args = lastArgs, thisArg = lastThis;
+			lastArgs = lastThis = void 0;
+			lastInvokeTime = time;
+			result = func.apply(thisArg, args);
+			return result;
+		}
+		function leadingEdge(time) {
+			lastInvokeTime = time;
+			timerId = setTimeout(timerExpired, wait);
+			return leading ? invokeFunc(time) : result;
+		}
+		function remainingWait(time) {
+			var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result$1 = wait - timeSinceLastCall;
+			return maxing ? nativeMin(result$1, maxWait - timeSinceLastInvoke) : result$1;
+		}
+		function shouldInvoke(time) {
+			var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+			return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+		}
+		function timerExpired() {
+			var time = now();
+			if (shouldInvoke(time)) return trailingEdge(time);
+			timerId = setTimeout(timerExpired, remainingWait(time));
+		}
+		function trailingEdge(time) {
+			timerId = void 0;
+			if (trailing && lastArgs) return invokeFunc(time);
+			lastArgs = lastThis = void 0;
+			return result;
+		}
+		function cancel() {
+			if (timerId !== void 0) clearTimeout(timerId);
+			lastInvokeTime = 0;
+			lastArgs = lastCallTime = lastThis = timerId = void 0;
+		}
+		function flush() {
+			return timerId === void 0 ? result : trailingEdge(now());
+		}
+		function debounced() {
+			var time = now(), isInvoking = shouldInvoke(time);
+			lastArgs = arguments;
+			lastThis = this;
+			lastCallTime = time;
+			if (isInvoking) {
+				if (timerId === void 0) return leadingEdge(lastCallTime);
+				if (maxing) {
+					timerId = setTimeout(timerExpired, wait);
+					return invokeFunc(lastCallTime);
+				}
+			}
+			if (timerId === void 0) timerId = setTimeout(timerExpired, wait);
+			return result;
+		}
+		debounced.cancel = cancel;
+		debounced.flush = flush;
+		return debounced;
+	}
+	/**
+	* Checks if `value` is the
+	* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	* @example
+	*
+	* _.isObject({});
+	* // => true
+	*
+	* _.isObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isObject(_.noop);
+	* // => true
+	*
+	* _.isObject(null);
+	* // => false
+	*/
+	function isObject(value) {
+		var type = typeof value;
+		return !!value && (type == "object" || type == "function");
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+	}
+	/**
+	* Converts `value` to a number.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {number} Returns the number.
+	* @example
+	*
+	* _.toNumber(3.2);
+	* // => 3.2
+	*
+	* _.toNumber(Number.MIN_VALUE);
+	* // => 5e-324
+	*
+	* _.toNumber(Infinity);
+	* // => Infinity
+	*
+	* _.toNumber('3.2');
+	* // => 3.2
+	*/
+	function toNumber(value) {
+		if (typeof value == "number") return value;
+		if (isSymbol(value)) return NAN;
+		if (isObject(value)) {
+			var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+			value = isObject(other) ? other + "" : other;
+		}
+		if (typeof value != "string") return value === 0 ? value : +value;
+		value = value.replace(reTrim, "");
+		var isBinary = reIsBinary.test(value);
+		return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+	}
+	module.exports = debounce;
+} });
+var import_lodash = __toESM(require_lodash(), 1);
+
+//#endregion
+//#region src/server/websockets-callbacks.ts
+const CALLBACK_URL = process.env.CALLBACK_URL ? new URL(process.env.CALLBACK_URL) : null;
+const CALLBACK_TIMEOUT = parseInt$1(process.env.CALLBACK_TIMEOUT || "5000");
+const CALLBACK_OBJECTS = process.env.CALLBACK_OBJECTS ? JSON.parse(process.env.CALLBACK_OBJECTS) : {};
+const isCallbackSet = !!CALLBACK_URL;
+const callbackHandler = (_update, _origin, doc) => {
+	const room = doc.name;
+	const dataToSend = {
+		room,
+		data: {}
+	};
+	const sharedObjectList = Object.keys(CALLBACK_OBJECTS);
+	sharedObjectList.forEach((sharedObjectName) => {
+		const sharedObjectType = CALLBACK_OBJECTS[sharedObjectName];
+		dataToSend.data[sharedObjectName] = {
+			type: sharedObjectType,
+			content: getContent(sharedObjectName, sharedObjectType, doc).toJSON()
+		};
+	});
+	if (CALLBACK_URL) callbackRequest(CALLBACK_URL, CALLBACK_TIMEOUT, dataToSend);
+};
+const callbackRequest = (url, timeout, data) => {
+	data = JSON.stringify(data);
+	const options = {
+		hostname: url.hostname,
+		port: url.port,
+		path: url.pathname,
+		timeout,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"Content-Length": Buffer.byteLength(data)
+		}
+	};
+	const req = http.request(options);
+	req.on("timeout", () => {
+		console.warn("Callback request timed out.");
+		req.abort();
+	});
+	req.on("error", (e) => {
+		console.error("Callback request error.", e);
+		req.abort();
+	});
+	req.write(data);
+	req.end();
+};
+const getContent = (objName, objType, doc) => {
+	switch (objType) {
+		case "Array": return doc.getArray(objName);
+		case "Map": return doc.getMap(objName);
+		case "Text": return doc.getText(objName);
+		case "XmlFragment": return doc.getXmlFragment(objName);
+		case "XmlElement": return doc.getXmlElement(objName);
+		default: return {};
+	}
+};
+
+//#endregion
+//#region src/server/websockets-utils.ts
+let actualServer = void 0;
+const CALLBACK_DEBOUNCE_WAIT = parseInt(process.env.CALLBACK_DEBOUNCE_WAIT || "2000");
+const CALLBACK_DEBOUNCE_MAXWAIT = parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT || "10000");
+const wsReadyStateConnecting = 0;
+const wsReadyStateOpen = 1;
+const gcEnabled = process.env.GC !== "false" && process.env.GC !== "0";
+const docs = new Map();
+const persistenceMap = new Map();
+const messageSync = 0;
+const messageAwareness = 1;
+const updateHandler = (update, _origin, doc) => {
+	const encoder = createEncoder();
+	writeVarUint(encoder, messageSync);
+	writeUpdate(encoder, update);
+	const message = toUint8Array(encoder);
+	doc.conns.forEach((_, conn) => send(doc, conn, message));
+};
+let contentInitializor = () => Promise.resolve();
+var WSSharedDoc = class extends Y$1.Doc {
+	constructor(name) {
+		super({ gc: gcEnabled });
+		this.name = name;
+		this.conns = new Map();
+		this.awareness = new Awareness(this);
+		this.awareness.setLocalState(null);
+		const awarenessChangeHandler = ({ added, updated, removed }, conn) => {
+			const changedClients = added.concat(updated, removed);
+			if (conn !== null) {
+				const connControlledIDs = this.conns.get(conn);
+				if (connControlledIDs !== void 0) {
+					added.forEach((clientID) => {
+						connControlledIDs.add(clientID);
+					});
+					removed.forEach((clientID) => {
+						connControlledIDs.delete(clientID);
+					});
+				}
+			}
+			const encoder = createEncoder();
+			writeVarUint(encoder, messageAwareness);
+			writeVarUint8Array(encoder, encodeAwarenessUpdate(this.awareness, changedClients));
+			const buff = toUint8Array(encoder);
+			this.conns.forEach((_, c) => {
+				send(this, c, buff);
+			});
+		};
+		this.awareness.on("update", awarenessChangeHandler);
+		this.on("update", updateHandler);
+		if (isCallbackSet) this.on("update", (0, import_lodash.default)(callbackHandler, CALLBACK_DEBOUNCE_WAIT, { maxWait: CALLBACK_DEBOUNCE_MAXWAIT }));
+		this.whenInitialized = contentInitializor();
+	}
+};
+const getYDoc = (docName, initialState, gc = true) => setIfUndefined(docs, docName, async () => {
+	let documentData = void 0;
+	if (actualServer && actualServer.fetchRoom) documentData = await actualServer.fetchRoom(docName);
+	const doc = new WSSharedDoc(docName);
+	doc.gc = gc;
+	docs.set(docName, doc);
+	if (documentData) Y$1.applyUpdate(doc, documentData);
+	else initialState(doc);
+	await setupRoomPersistence(docName, doc);
+	return doc;
+});
+const messageListener = (conn, doc, message) => {
+	try {
+		const encoder = createEncoder();
+		const decoder = createDecoder(message);
+		const messageType = readVarUint(decoder);
+		switch (messageType) {
+			case messageSync:
+				writeVarUint(encoder, messageSync);
+				readSyncMessage(decoder, encoder, doc, conn);
+				if (length$1(encoder) > 1) send(doc, conn, toUint8Array(encoder));
+				break;
+			case messageAwareness: {
+				applyAwarenessUpdate(doc.awareness, readVarUint8Array(decoder), conn);
+				break;
+			}
+		}
+	} catch (err) {
+		console.error(err);
+	}
+};
+const closeConn = (doc, conn) => {
+	if (doc.conns.has(conn)) {
+		/**
+		* @type {Set<number>}
+		*/
+		const controlledIds = doc.conns.get(conn);
+		doc.conns.delete(conn);
+		if (persistenceMap.has(doc.name)) clearInterval(persistenceMap.get(doc.name));
+		removeAwarenessStates(doc.awareness, Array.from(controlledIds), null);
+	}
+	conn.close();
+};
+const send = (doc, conn, m) => {
+	if (conn.readyState !== wsReadyStateConnecting && conn.readyState !== wsReadyStateOpen) closeConn(doc, conn);
+	try {
+		conn.send(m, {}, (err) => {
+			if (err != null) closeConn(doc, conn);
+		});
+	} catch (e) {
+		closeConn(doc, conn);
+	}
+};
+const pingTimeout = 3e4;
+const setServer = (server) => {
+	actualServer = server;
+};
+const setupWSConnection = (getDocName, initialState) => {
+	return async (conn, req, { gc = true } = {}) => {
+		const docName = getDocName(req);
+		if (!docName) return;
+		conn.binaryType = "arraybuffer";
+		const doc = await getYDoc(docName, initialState, gc);
+		doc.conns.set(conn, new Set());
+		conn.on("message", (message) => messageListener(conn, doc, new Uint8Array(message)));
+		let pongReceived = true;
+		const pingInterval = setInterval(() => {
+			if (!pongReceived) {
+				if (doc.conns.has(conn)) closeConn(doc, conn);
+				clearInterval(pingInterval);
+			} else if (doc.conns.has(conn)) {
+				pongReceived = false;
+				try {
+					conn.ping();
+				} catch (e) {
+					closeConn(doc, conn);
+					clearInterval(pingInterval);
+				}
+			}
+		}, pingTimeout);
+		conn.on("close", () => {
+			closeConn(doc, conn);
+			clearInterval(pingInterval);
+		});
+		conn.on("pong", () => {
+			pongReceived = true;
+		});
+		{
+			const encoder = createEncoder();
+			writeVarUint(encoder, messageSync);
+			writeSyncStep1(encoder, doc);
+			send(doc, conn, toUint8Array(encoder));
+			const awarenessStates = doc.awareness.getStates();
+			if (awarenessStates.size > 0) {
+				const encoder$1 = createEncoder();
+				writeVarUint(encoder$1, messageAwareness);
+				writeVarUint8Array(encoder$1, encodeAwarenessUpdate(doc.awareness, Array.from(awarenessStates.keys())));
+				send(doc, conn, toUint8Array(encoder$1));
+			}
+		}
+	};
+};
+async function setupRoomPersistence(roomId, doc) {
+	if (!persistenceMap.has(roomId)) {
+		const persistHandler = async () => {
+			const actualState = Y$1.encodeStateAsUpdate(doc);
+			if (actualServer && actualServer.persistRoom) try {
+				await actualServer.persistRoom(roomId, actualState);
+			} catch (ex) {
+				console.error(ex);
+			}
+		};
+		persistHandler();
+		const intervalId = setInterval(persistHandler, parseInt(process.env.WEAVE_WEBSOCKETS_STATE_SYNC_FREQUENCY_SEG ?? "10") * 1e3);
+		persistenceMap.set(roomId, intervalId);
+	}
 }
-class et {
-  constructor({
-    initialState: n = He,
-    performUpgrade: t,
-    extractRoomId: r,
-    persistRoom: s,
-    fetchRoom: i
-  }) {
-    d(this, "initialState");
-    d(this, "performUpgrade");
-    d(this, "extractRoomId");
-    d(this, "wss");
-    d(this, "persistRoom");
-    d(this, "fetchRoom");
-    this.initialState = n, this.performUpgrade = t, this.extractRoomId = r, this.persistRoom = s, this.fetchRoom = i, this.wss = new q({ noServer: !0 }), $e(this), this.wss.on(
-      "connection",
-      ze(this.extractRoomId, this.initialState)
-    );
-  }
-  handleUpgrade(n) {
-    n.on("upgrade", async (t, r, s) => {
-      await this.performUpgrade(t) && this.wss.handleUpgrade(t, r, s, (a) => {
-        this.wss.emit("connection", a, t);
-      });
-    });
-  }
+
+//#endregion
+//#region src/server/default-initial-state.ts
+const yjsLayer = function(id) {
+	const newLayerMap = new Y.Map();
+	newLayerMap.set("key", id);
+	newLayerMap.set("type", "layer");
+	const newLayerMapProps = new Y.Map();
+	newLayerMapProps.set("id", id);
+	newLayerMapProps.set("nodeType", "layer");
+	newLayerMapProps.set("children", new Y.Array());
+	newLayerMap.set("props", newLayerMapProps);
+	return newLayerMap;
+};
+function defaultInitialState(doc) {
+	const children = new Y.Array();
+	children.insert(0, [
+		yjsLayer("gridLayer"),
+		yjsLayer("mainLayer"),
+		yjsLayer("selectionLayer"),
+		yjsLayer("usersPointersLayer"),
+		yjsLayer("utilityLayer")
+	]);
+	const stageProps = new Y.Map();
+	stageProps.set("id", "stage");
+	stageProps.set("children", children);
+	doc.getMap("weave").set("key", "stage");
+	doc.getMap("weave").set("type", "stage");
+	doc.getMap("weave").set("props", stageProps);
 }
-export {
-  st as WEAVE_STORE_WEBSOCKETS,
-  rt as WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS,
-  et as WeaveWebsocketsServer
+
+//#endregion
+//#region src/server/websockets-server.ts
+var WeaveWebsocketsServer = class {
+	persistRoom = void 0;
+	fetchRoom = void 0;
+	constructor({ initialState = defaultInitialState, performUpgrade, extractRoomId, persistRoom, fetchRoom }) {
+		this.initialState = initialState;
+		this.performUpgrade = performUpgrade;
+		this.extractRoomId = extractRoomId;
+		this.persistRoom = persistRoom;
+		this.fetchRoom = fetchRoom;
+		this.wss = new WebSocketServer({ noServer: true });
+		setServer(this);
+		this.wss.on("connection", setupWSConnection(this.extractRoomId, this.initialState));
+	}
+	handleUpgrade(server) {
+		server.on("upgrade", async (request, socket, head) => {
+			const continueToUpgrade = await this.performUpgrade(request);
+			if (!continueToUpgrade) return;
+			this.wss.handleUpgrade(request, socket, head, (ws) => {
+				this.wss.emit("connection", ws, request);
+			});
+		});
+	}
 };
+
+//#endregion
+export { WEAVE_STORE_WEBSOCKETS, WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS, WeaveWebsocketsServer };