@inditextech/weave-store-websockets 0.1.0 → 0.2.0

package/dist/server.cjs

@@ -1 +1,1593 @@
-"use strict";var F=Object.defineProperty;var X=(e,n,t)=>n in e?F(e,n,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[n]=t;var d=(e,n,t)=>(X(e,typeof n!="symbol"?n+"":n,t),t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const J=require("ws"),z=require("yjs"),a=require("./awareness-BgEfnEJw.cjs"),G=require("http");function H(e){const n=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const t in e)if(t!=="default"){const r=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(n,t,r.get?r:{enumerable:!0,get:()=>e[t]})}}return n.default=e,Object.freeze(n)}const h=H(z);var b=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function Y(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var $="Expected a function",k=NaN,Q="[object Symbol]",Z=/^\s+|\s+$/g,ee=/^[-+]0x[0-9a-f]+$/i,te=/^0b[01]+$/i,ne=/^0o[0-7]+$/i,re=parseInt,se=typeof b=="object"&&b&&b.Object===Object&&b,ae=typeof self=="object"&&self&&self.Object===Object&&self,oe=se||ae||Function("return this")(),ie=Object.prototype,ce=ie.toString,le=Math.max,fe=Math.min,U=function(){return oe.Date.now()};function ue(e,n,t){var r,s,c,o,i,p,f=0,m=!1,u=!1,y=!0;if(typeof e!="function")throw new TypeError($);n=K(n)||0,I(t)&&(m=!!t.leading,u="maxWait"in t,c=u?le(K(t.maxWait)||0,n):c,y="trailing"in t?!!t.trailing:y);function L(l){var g=r,E=s;return r=s=void 0,f=l,o=e.apply(E,g),o}function V(l){return f=l,i=setTimeout(T,n),m?L(l):o}function P(l){var g=l-p,E=l-f,j=n-g;return u?fe(j,c-E):j}function M(l){var g=l-p,E=l-f;return p===void 0||g>=n||g<0||u&&E>=c}function T(){var l=U();if(M(l))return W(l);i=setTimeout(T,P(l))}function W(l){return i=void 0,y&&r?L(l):(r=s=void 0,o)}function N(){i!==void 0&&clearTimeout(i),f=0,r=p=s=i=void 0}function q(){return i===void 0?o:W(U())}function _(){var l=U(),g=M(l);if(r=arguments,s=this,p=l,g){if(i===void 0)return V(p);if(u)return i=setTimeout(T,n),L(p)}return i===void 0&&(i=setTimeout(T,n)),o}return _.cancel=N,_.flush=q,_}function I(e){var n=typeof e;return!!e&&(n=="object"||n=="function")}function pe(e){return!!e&&typeof e=="object"}function de(e){return typeof e=="symbol"||pe(e)&&ce.call(e)==Q}function K(e){if(typeof e=="number")return e;if(de(e))return k;if(I(e)){var n=typeof e.valueOf=="function"?e.valueOf():e;e=I(n)?n+"":n}if(typeof e!="string")return e===0?e:+e;e=e.replace(Z,"");var t=te.test(e);return t||ne.test(e)?re(e.slice(2),t?2:8):ee.test(e)?k:+e}var ye=ue;const ge=Y(ye),B=process.env.CALLBACK_URL?new URL(process.env.CALLBACK_URL):null,he=a.parseInt(process.env.CALLBACK_TIMEOUT||"5000"),x=process.env.CALLBACK_OBJECTS?JSON.parse(process.env.CALLBACK_OBJECTS):{},me=!!B,Se=(e,n,t)=>{const s={room:t.name,data:{}};Object.keys(x).forEach(o=>{const i=x[o];s.data[o]={type:i,content:Ee(o,i,t).toJSON()}}),B&&we(B,he,s)},we=(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=G.request(r);s.on("timeout",()=>{console.warn("Callback request timed out."),s.abort()}),s.on("error",c=>{console.error("Callback request error.",c),s.abort()}),s.write(t),s.end()},Ee=(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 S;const Ae=parseInt(process.env.CALLBACK_DEBOUNCE_WAIT||"2000"),Ce=parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT||"10000"),Te=0,be=1,ve=process.env.GC!=="false"&&process.env.GC!=="0",D=new Map,v=new Map,O=0,R=1,Oe=(e,n,t)=>{const r=a.createEncoder();a.writeVarUint(r,O),a.writeUpdate(r,e);const s=a.toUint8Array(r);t.conns.forEach((c,o)=>C(t,o,s))};let Le=()=>Promise.resolve();class _e extends h.Doc{constructor(t){super({gc:ve});d(this,"name");d(this,"conns");d(this,"awareness");d(this,"whenInitialized");this.name=t,this.conns=new Map,this.awareness=new a.Awareness(this),this.awareness.setLocalState(null);const r=({added:s,updated:c,removed:o},i)=>{const p=s.concat(c,o);if(i!==null){const u=this.conns.get(i);u!==void 0&&(s.forEach(y=>{u.add(y)}),o.forEach(y=>{u.delete(y)}))}const f=a.createEncoder();a.writeVarUint(f,R),a.writeVarUint8Array(f,a.encodeAwarenessUpdate(this.awareness,p));const m=a.toUint8Array(f);this.conns.forEach((u,y)=>{C(this,y,m)})};this.awareness.on("update",r),this.on("update",Oe),me&&this.on("update",ge(Se,Ae,{maxWait:Ce})),this.whenInitialized=Le()}}const Ue=(e,n,t=!0)=>a.setIfUndefined(D,e,async()=>{let r;S&&S.fetchRoom&&(r=await S.fetchRoom(e));const s=new _e(e);return s.gc=t,D.set(e,s),r?h.applyUpdate(s,r):n(s),await We(e,s),s}),Ie=(e,n,t)=>{try{const r=a.createEncoder(),s=a.createDecoder(t);switch(a.readVarUint(s)){case O:a.writeVarUint(r,O),a.readSyncMessage(s,r,n,e),a.length(r)>1&&C(n,e,a.toUint8Array(r));break;case R:{a.applyAwarenessUpdate(n.awareness,a.readVarUint8Array(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),v.has(e.name)&&clearInterval(v.get(e.name)),a.removeAwarenessStates(e.awareness,Array.from(t),null)}n.close()},C=(e,n,t)=>{n.readyState!==Te&&n.readyState!==be&&w(e,n);try{n.send(t,{},r=>{r!=null&&w(e,n)})}catch{w(e,n)}},Be=3e4,Re=e=>{S=e},Me=(e,n)=>async(t,r,{gc:s=!0}={})=>{const c=e(r);if(!c)return;t.binaryType="arraybuffer";const o=await Ue(c,n,s);o.conns.set(t,new Set),t.on("message",f=>Ie(t,o,new Uint8Array(f)));let i=!0;const p=setInterval(()=>{if(!i)o.conns.has(t)&&w(o,t),clearInterval(p);else if(o.conns.has(t)){i=!1;try{t.ping()}catch{w(o,t),clearInterval(p)}}},Be);t.on("close",()=>{w(o,t),clearInterval(p)}),t.on("pong",()=>{i=!0});{const f=a.createEncoder();a.writeVarUint(f,O),a.writeSyncStep1(f,o),C(o,t,a.toUint8Array(f));const m=o.awareness.getStates();if(m.size>0){const u=a.createEncoder();a.writeVarUint(u,R),a.writeVarUint8Array(u,a.encodeAwarenessUpdate(o.awareness,Array.from(m.keys()))),C(o,t,a.toUint8Array(u))}}};async function We(e,n){if(!v.has(e)){const t=async()=>{const s=h.encodeStateAsUpdate(n);if(S&&S.persistRoom)try{await S.persistRoom(e,s)}catch(c){console.error(c)}};t();const r=setInterval(t,parseInt(process.env.WEAVE_WEBSOCKETS_STATE_SYNC_FREQUENCY_SEG??"10")*1e3);v.set(e,r)}}const A=function(e){const n=new h.Map;n.set("key",e),n.set("type","layer");const t=new h.Map;return t.set("id",e),t.set("nodeType","layer"),t.set("children",new h.Array),n.set("props",t),n};function je(e){const n=new h.Array;n.insert(0,[A("gridLayer"),A("mainLayer"),A("selectionLayer"),A("usersPointersLayer"),A("utilityLayer")]);const t=new h.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)}class ke{constructor({initialState:n=je,performUpgrade:t,extractRoomId:r,persistRoom:s,fetchRoom:c}){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=c,this.wss=new J.WebSocketServer({noServer:!0}),Re(this),this.wss.on("connection",Me(this.extractRoomId,this.initialState))}handleUpgrade(n){n.on("upgrade",async(t,r,s)=>{await this.performUpgrade(t)&&this.wss.handleUpgrade(t,r,s,o=>{this.wss.emit("connection",o,t)})})}}exports.WEAVE_STORE_WEBSOCKETS=a.WEAVE_STORE_WEBSOCKETS;exports.WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS=a.WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS;exports.WeaveWebsocketsServer=ke;
+const require_types = require('./types-BH9hIv5b.cjs');
+const http = require_types.__toESM(require("http"));
+require("https");
+const ws = require_types.__toESM(require("ws"));
+const yjs = require_types.__toESM(require("yjs"));
+require("node:http");
+
+//#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 = yjs.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, yjs.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 {
+		yjs.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 = require_types.__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 = require_types.__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.default.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 yjs.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) yjs.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 = yjs.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);
+	}
+}
+
+//#endregion
+//#region src/server/default-initial-state.ts
+const yjsLayer = function(id) {
+	const newLayerMap = new yjs.Map();
+	newLayerMap.set("key", id);
+	newLayerMap.set("type", "layer");
+	const newLayerMapProps = new yjs.Map();
+	newLayerMapProps.set("id", id);
+	newLayerMapProps.set("nodeType", "layer");
+	newLayerMapProps.set("children", new yjs.Array());
+	newLayerMap.set("props", newLayerMapProps);
+	return newLayerMap;
+};
+function defaultInitialState(doc) {
+	const children = new yjs.Array();
+	children.insert(0, [
+		yjsLayer("gridLayer"),
+		yjsLayer("mainLayer"),
+		yjsLayer("selectionLayer"),
+		yjsLayer("usersPointersLayer"),
+		yjsLayer("utilityLayer")
+	]);
+	const stageProps = new yjs.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);
+}
+
+//#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 ws.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$1) => {
+				this.wss.emit("connection", ws$1, request);
+			});
+		});
+	}
+};
+
+//#endregion
+exports.WEAVE_STORE_WEBSOCKETS = require_types.WEAVE_STORE_WEBSOCKETS
+exports.WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS = require_types.WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS
+exports.WeaveWebsocketsServer = WeaveWebsocketsServer