Gutenberg / 23.6.2

Gutenberg v23.6.2

gutenberg / build / scripts / sync / index.js

index.js in Gutenberg 23.6.2, at build/scripts/sync/index.js

12,868 lines 393.7 KB

Raw Download Zip

1	"use strict";
2	var wp;
3	(wp \|\|= {}).sync = (() => {
4	var __create = Object.create;
5	var __defProp = Object.defineProperty;
6	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
7	var __getOwnPropNames = Object.getOwnPropertyNames;
8	var __getProtoOf = Object.getPrototypeOf;
9	var __hasOwnProp = Object.prototype.hasOwnProperty;
10	var __commonJS = (cb, mod) => function __require() {
11	return mod \|\| (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
12	};
13	var __export = (target, all2) => {
14	for (var name in all2)
15	__defProp(target, name, { get: all2[name], enumerable: true });
16	};
17	var __copyProps = (to, from2, except, desc) => {
18	if (from2 && typeof from2 === "object" \|\| typeof from2 === "function") {
19	for (let key of __getOwnPropNames(from2))
20	if (!__hasOwnProp.call(to, key) && key !== except)
21	__defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) \|\| desc.enumerable });
22	}
23	return to;
24	};
25	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
26	// If the importer is in node compatibility mode or this is not an ESM
27	// file that has been converted to a CommonJS file using a Babel-
28	// compatible transform (i.e. "__esModule" has not been set), then set
29	// "default" to the CommonJS "module.exports" for node compatibility.
30	isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
31	mod
32	));
33	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
34
35	// package-external:@wordpress/private-apis
36	var require_private_apis = __commonJS({
37	"package-external:@wordpress/private-apis"(exports, module) {
38	module.exports = window.wp.privateApis;
39	}
40	});
41
42	// package-external:@wordpress/hooks
43	var require_hooks = __commonJS({
44	"package-external:@wordpress/hooks"(exports, module) {
45	module.exports = window.wp.hooks;
46	}
47	});
48
49	// package-external:@wordpress/api-fetch
50	var require_api_fetch = __commonJS({
51	"package-external:@wordpress/api-fetch"(exports, module) {
52	module.exports = window.wp.apiFetch;
53	}
54	});
55
56	// node_modules/fast-deep-equal/es6/index.js
57	var require_es6 = __commonJS({
58	"node_modules/fast-deep-equal/es6/index.js"(exports, module) {
59	"use strict";
60	module.exports = function equal(a, b) {
61	if (a === b) return true;
62	if (a && b && typeof a == "object" && typeof b == "object") {
63	if (a.constructor !== b.constructor) return false;
64	var length2, i, keys2;
65	if (Array.isArray(a)) {
66	length2 = a.length;
67	if (length2 != b.length) return false;
68	for (i = length2; i-- !== 0; )
69	if (!equal(a[i], b[i])) return false;
70	return true;
71	}
72	if (a instanceof Map && b instanceof Map) {
73	if (a.size !== b.size) return false;
74	for (i of a.entries())
75	if (!b.has(i[0])) return false;
76	for (i of a.entries())
77	if (!equal(i[1], b.get(i[0]))) return false;
78	return true;
79	}
80	if (a instanceof Set && b instanceof Set) {
81	if (a.size !== b.size) return false;
82	for (i of a.entries())
83	if (!b.has(i[0])) return false;
84	return true;
85	}
86	if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
87	length2 = a.length;
88	if (length2 != b.length) return false;
89	for (i = length2; i-- !== 0; )
90	if (a[i] !== b[i]) return false;
91	return true;
92	}
93	if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
94	if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
95	if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
96	keys2 = Object.keys(a);
97	length2 = keys2.length;
98	if (length2 !== Object.keys(b).length) return false;
99	for (i = length2; i-- !== 0; )
100	if (!Object.prototype.hasOwnProperty.call(b, keys2[i])) return false;
101	for (i = length2; i-- !== 0; ) {
102	var key = keys2[i];
103	if (!equal(a[key], b[key])) return false;
104	}
105	return true;
106	}
107	return a !== a && b !== b;
108	};
109	}
110	});
111
112	// packages/sync/build-module/index.mjs
113	var index_exports = {};
114	__export(index_exports, {
115	Awareness: () => Awareness,
116	Y: () => yjs_exports,
117	YJS_VERSION: () => YJS_VERSION,
118	privateApis: () => privateApis
119	});
120
121	// node_modules/yjs/dist/yjs.mjs
122	var yjs_exports = {};
123	__export(yjs_exports, {
124	AbsolutePosition: () => AbsolutePosition,
125	AbstractConnector: () => AbstractConnector,
126	AbstractStruct: () => AbstractStruct,
127	AbstractType: () => AbstractType,
128	Array: () => YArray,
129	ContentAny: () => ContentAny,
130	ContentBinary: () => ContentBinary,
131	ContentDeleted: () => ContentDeleted,
132	ContentDoc: () => ContentDoc,
133	ContentEmbed: () => ContentEmbed,
134	ContentFormat: () => ContentFormat,
135	ContentJSON: () => ContentJSON,
136	ContentString: () => ContentString,
137	ContentType: () => ContentType,
138	Doc: () => Doc,
139	GC: () => GC,
140	ID: () => ID,
141	Item: () => Item,
142	Map: () => YMap,
143	PermanentUserData: () => PermanentUserData,
144	RelativePosition: () => RelativePosition,
145	Skip: () => Skip,
146	Snapshot: () => Snapshot,
147	Text: () => YText,
148	Transaction: () => Transaction,
149	UndoManager: () => UndoManager,
150	UpdateDecoderV1: () => UpdateDecoderV1,
151	UpdateDecoderV2: () => UpdateDecoderV2,
152	UpdateEncoderV1: () => UpdateEncoderV1,
153	UpdateEncoderV2: () => UpdateEncoderV2,
154	XmlElement: () => YXmlElement,
155	XmlFragment: () => YXmlFragment,
156	XmlHook: () => YXmlHook,
157	XmlText: () => YXmlText,
158	YArrayEvent: () => YArrayEvent,
159	YEvent: () => YEvent,
160	YMapEvent: () => YMapEvent,
161	YTextEvent: () => YTextEvent,
162	YXmlEvent: () => YXmlEvent,
163	applyUpdate: () => applyUpdate,
164	applyUpdateV2: () => applyUpdateV2,
165	cleanupYTextFormatting: () => cleanupYTextFormatting,
166	compareIDs: () => compareIDs,
167	compareRelativePositions: () => compareRelativePositions,
168	convertUpdateFormatV1ToV2: () => convertUpdateFormatV1ToV2,
169	convertUpdateFormatV2ToV1: () => convertUpdateFormatV2ToV1,
170	createAbsolutePositionFromRelativePosition: () => createAbsolutePositionFromRelativePosition,
171	createDeleteSet: () => createDeleteSet,
172	createDeleteSetFromStructStore: () => createDeleteSetFromStructStore,
173	createDocFromSnapshot: () => createDocFromSnapshot,
174	createID: () => createID,
175	createRelativePositionFromJSON: () => createRelativePositionFromJSON,
176	createRelativePositionFromTypeIndex: () => createRelativePositionFromTypeIndex,
177	createSnapshot: () => createSnapshot,
178	decodeRelativePosition: () => decodeRelativePosition,
179	decodeSnapshot: () => decodeSnapshot,
180	decodeSnapshotV2: () => decodeSnapshotV2,
181	decodeStateVector: () => decodeStateVector,
182	decodeUpdate: () => decodeUpdate,
183	decodeUpdateV2: () => decodeUpdateV2,
184	diffUpdate: () => diffUpdate,
185	diffUpdateV2: () => diffUpdateV2,
186	emptySnapshot: () => emptySnapshot,
187	encodeRelativePosition: () => encodeRelativePosition,
188	encodeSnapshot: () => encodeSnapshot,
189	encodeSnapshotV2: () => encodeSnapshotV2,
190	encodeStateAsUpdate: () => encodeStateAsUpdate,
191	encodeStateAsUpdateV2: () => encodeStateAsUpdateV2,
192	encodeStateVector: () => encodeStateVector,
193	encodeStateVectorFromUpdate: () => encodeStateVectorFromUpdate,
194	encodeStateVectorFromUpdateV2: () => encodeStateVectorFromUpdateV2,
195	equalDeleteSets: () => equalDeleteSets,
196	equalSnapshots: () => equalSnapshots,
197	findIndexSS: () => findIndexSS,
198	findRootTypeKey: () => findRootTypeKey,
199	getItem: () => getItem,
200	getItemCleanEnd: () => getItemCleanEnd,
201	getItemCleanStart: () => getItemCleanStart,
202	getState: () => getState,
203	getTypeChildren: () => getTypeChildren,
204	isDeleted: () => isDeleted,
205	isParentOf: () => isParentOf,
206	iterateDeletedStructs: () => iterateDeletedStructs,
207	logType: () => logType,
208	logUpdate: () => logUpdate,
209	logUpdateV2: () => logUpdateV2,
210	mergeDeleteSets: () => mergeDeleteSets,
211	mergeUpdates: () => mergeUpdates,
212	mergeUpdatesV2: () => mergeUpdatesV2,
213	obfuscateUpdate: () => obfuscateUpdate,
214	obfuscateUpdateV2: () => obfuscateUpdateV2,
215	parseUpdateMeta: () => parseUpdateMeta,
216	parseUpdateMetaV2: () => parseUpdateMetaV2,
217	readUpdate: () => readUpdate,
218	readUpdateV2: () => readUpdateV2,
219	relativePositionToJSON: () => relativePositionToJSON,
220	snapshot: () => snapshot,
221	snapshotContainsUpdate: () => snapshotContainsUpdate,
222	transact: () => transact,
223	tryGc: () => tryGc,
224	typeListToArraySnapshot: () => typeListToArraySnapshot,
225	typeMapGetAllSnapshot: () => typeMapGetAllSnapshot,
226	typeMapGetSnapshot: () => typeMapGetSnapshot
227	});
228
229	// node_modules/lib0/map.js
230	var create = () => /* @__PURE__ */ new Map();
231	var copy = (m) => {
232	const r = create();
233	m.forEach((v, k) => {
234	r.set(k, v);
235	});
236	return r;
237	};
238	var setIfUndefined = (map2, key, createT) => {
239	let set = map2.get(key);
240	if (set === void 0) {
241	map2.set(key, set = createT());
242	}
243	return set;
244	};
245	var map = (m, f) => {
246	const res = [];
247	for (const [key, value] of m) {
248	res.push(f(value, key));
249	}
250	return res;
251	};
252	var any = (m, f) => {
253	for (const [key, value] of m) {
254	if (f(value, key)) {
255	return true;
256	}
257	}
258	return false;
259	};
260
261	// node_modules/lib0/set.js
262	var create2 = () => /* @__PURE__ */ new Set();
263
264	// node_modules/lib0/array.js
265	var last = (arr) => arr[arr.length - 1];
266	var appendTo = (dest, src) => {
267	for (let i = 0; i < src.length; i++) {
268	dest.push(src[i]);
269	}
270	};
271	var from = Array.from;
272	var every = (arr, f) => {
273	for (let i = 0; i < arr.length; i++) {
274	if (!f(arr[i], i, arr)) {
275	return false;
276	}
277	}
278	return true;
279	};
280	var some = (arr, f) => {
281	for (let i = 0; i < arr.length; i++) {
282	if (f(arr[i], i, arr)) {
283	return true;
284	}
285	}
286	return false;
287	};
288	var unfold = (len, f) => {
289	const array = new Array(len);
290	for (let i = 0; i < len; i++) {
291	array[i] = f(i, array);
292	}
293	return array;
294	};
295	var isArray = Array.isArray;
296
297	// node_modules/lib0/observable.js
298	var ObservableV2 = class {
299	constructor() {
300	this._observers = create();
301	}
302	/**
303	* @template {keyof EVENTS & string} NAME
304	* @param {NAME} name
305	* @param {EVENTS[NAME]} f
306	*/
307	on(name, f) {
308	setIfUndefined(
309	this._observers,
310	/** @type {string} */
311	name,
312	create2
313	).add(f);
314	return f;
315	}
316	/**
317	* @template {keyof EVENTS & string} NAME
318	* @param {NAME} name
319	* @param {EVENTS[NAME]} f
320	*/
321	once(name, f) {
322	const _f = (...args2) => {
323	this.off(
324	name,
325	/** @type {any} */
326	_f
327	);
328	f(...args2);
329	};
330	this.on(
331	name,
332	/** @type {any} */
333	_f
334	);
335	}
336	/**
337	* @template {keyof EVENTS & string} NAME
338	* @param {NAME} name
339	* @param {EVENTS[NAME]} f
340	*/
341	off(name, f) {
342	const observers = this._observers.get(name);
343	if (observers !== void 0) {
344	observers.delete(f);
345	if (observers.size === 0) {
346	this._observers.delete(name);
347	}
348	}
349	}
350	/**
351	* Emit a named event. All registered event listeners that listen to the
352	* specified name will receive the event.
353	*
354	* @todo This should catch exceptions
355	*
356	* @template {keyof EVENTS & string} NAME
357	* @param {NAME} name The event name.
358	* @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
359	*/
360	emit(name, args2) {
361	return from((this._observers.get(name) \|\| create()).values()).forEach((f) => f(...args2));
362	}
363	destroy() {
364	this._observers = create();
365	}
366	};
367	var Observable = class {
368	constructor() {
369	this._observers = create();
370	}
371	/**
372	* @param {N} name
373	* @param {function} f
374	*/
375	on(name, f) {
376	setIfUndefined(this._observers, name, create2).add(f);
377	}
378	/**
379	* @param {N} name
380	* @param {function} f
381	*/
382	once(name, f) {
383	const _f = (...args2) => {
384	this.off(name, _f);
385	f(...args2);
386	};
387	this.on(name, _f);
388	}
389	/**
390	* @param {N} name
391	* @param {function} f
392	*/
393	off(name, f) {
394	const observers = this._observers.get(name);
395	if (observers !== void 0) {
396	observers.delete(f);
397	if (observers.size === 0) {
398	this._observers.delete(name);
399	}
400	}
401	}
402	/**
403	* Emit a named event. All registered event listeners that listen to the
404	* specified name will receive the event.
405	*
406	* @todo This should catch exceptions
407	*
408	* @param {N} name The event name.
409	* @param {Array<any>} args The arguments that are applied to the event listener.
410	*/
411	emit(name, args2) {
412	return from((this._observers.get(name) \|\| create()).values()).forEach((f) => f(...args2));
413	}
414	destroy() {
415	this._observers = create();
416	}
417	};
418
419	// node_modules/lib0/math.js
420	var floor = Math.floor;
421	var abs = Math.abs;
422	var min = (a, b) => a < b ? a : b;
423	var max = (a, b) => a > b ? a : b;
424	var isNaN2 = Number.isNaN;
425	var isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
426
427	// node_modules/lib0/binary.js
428	var BIT1 = 1;
429	var BIT2 = 2;
430	var BIT3 = 4;
431	var BIT4 = 8;
432	var BIT6 = 32;
433	var BIT7 = 64;
434	var BIT8 = 128;
435	var BIT18 = 1 << 17;
436	var BIT19 = 1 << 18;
437	var BIT20 = 1 << 19;
438	var BIT21 = 1 << 20;
439	var BIT22 = 1 << 21;
440	var BIT23 = 1 << 22;
441	var BIT24 = 1 << 23;
442	var BIT25 = 1 << 24;
443	var BIT26 = 1 << 25;
444	var BIT27 = 1 << 26;
445	var BIT28 = 1 << 27;
446	var BIT29 = 1 << 28;
447	var BIT30 = 1 << 29;
448	var BIT31 = 1 << 30;
449	var BIT32 = 1 << 31;
450	var BITS5 = 31;
451	var BITS6 = 63;
452	var BITS7 = 127;
453	var BITS17 = BIT18 - 1;
454	var BITS18 = BIT19 - 1;
455	var BITS19 = BIT20 - 1;
456	var BITS20 = BIT21 - 1;
457	var BITS21 = BIT22 - 1;
458	var BITS22 = BIT23 - 1;
459	var BITS23 = BIT24 - 1;
460	var BITS24 = BIT25 - 1;
461	var BITS25 = BIT26 - 1;
462	var BITS26 = BIT27 - 1;
463	var BITS27 = BIT28 - 1;
464	var BITS28 = BIT29 - 1;
465	var BITS29 = BIT30 - 1;
466	var BITS30 = BIT31 - 1;
467	var BITS31 = 2147483647;
468
469	// node_modules/lib0/number.js
470	var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
471	var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
472	var LOWEST_INT32 = 1 << 31;
473	var isInteger = Number.isInteger \|\| ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
474	var isNaN3 = Number.isNaN;
475	var parseInt2 = Number.parseInt;
476
477	// node_modules/lib0/string.js
478	var fromCharCode = String.fromCharCode;
479	var fromCodePoint = String.fromCodePoint;
480	var MAX_UTF16_CHARACTER = fromCharCode(65535);
481	var toLowerCase = (s) => s.toLowerCase();
482	var trimLeftRegex = /^\s*/g;
483	var trimLeft = (s) => s.replace(trimLeftRegex, "");
484	var fromCamelCaseRegex = /([A-Z])/g;
485	var fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
486	var _encodeUtf8Polyfill = (str) => {
487	const encodedString = unescape(encodeURIComponent(str));
488	const len = encodedString.length;
489	const buf = new Uint8Array(len);
490	for (let i = 0; i < len; i++) {
491	buf[i] = /** @type {number} */
492	encodedString.codePointAt(i);
493	}
494	return buf;
495	};
496	var utf8TextEncoder = (
497	/** @type {TextEncoder} */
498	typeof TextEncoder !== "undefined" ? new TextEncoder() : null
499	);
500	var _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
501	var encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
502	var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
503	if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
504	utf8TextDecoder = null;
505	}
506	var repeat = (source, n) => unfold(n, () => source).join("");
507
508	// node_modules/lib0/encoding.js
509	var Encoder = class {
510	constructor() {
511	this.cpos = 0;
512	this.cbuf = new Uint8Array(100);
513	this.bufs = [];
514	}
515	};
516	var createEncoder = () => new Encoder();
517	var length = (encoder) => {
518	let len = encoder.cpos;
519	for (let i = 0; i < encoder.bufs.length; i++) {
520	len += encoder.bufs[i].length;
521	}
522	return len;
523	};
524	var toUint8Array = (encoder) => {
525	const uint8arr = new Uint8Array(length(encoder));
526	let curPos = 0;
527	for (let i = 0; i < encoder.bufs.length; i++) {
528	const d = encoder.bufs[i];
529	uint8arr.set(d, curPos);
530	curPos += d.length;
531	}
532	uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
533	return uint8arr;
534	};
535	var verifyLen = (encoder, len) => {
536	const bufferLen = encoder.cbuf.length;
537	if (bufferLen - encoder.cpos < len) {
538	encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos));
539	encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
540	encoder.cpos = 0;
541	}
542	};
543	var write = (encoder, num) => {
544	const bufferLen = encoder.cbuf.length;
545	if (encoder.cpos === bufferLen) {
546	encoder.bufs.push(encoder.cbuf);
547	encoder.cbuf = new Uint8Array(bufferLen * 2);
548	encoder.cpos = 0;
549	}
550	encoder.cbuf[encoder.cpos++] = num;
551	};
552	var writeUint8 = write;
553	var writeVarUint = (encoder, num) => {
554	while (num > BITS7) {
555	write(encoder, BIT8 \| BITS7 & num);
556	num = floor(num / 128);
557	}
558	write(encoder, BITS7 & num);
559	};
560	var writeVarInt = (encoder, num) => {
561	const isNegative = isNegativeZero(num);
562	if (isNegative) {
563	num = -num;
564	}
565	write(encoder, (num > BITS6 ? BIT8 : 0) \| (isNegative ? BIT7 : 0) \| BITS6 & num);
566	num = floor(num / 64);
567	while (num > 0) {
568	write(encoder, (num > BITS7 ? BIT8 : 0) \| BITS7 & num);
569	num = floor(num / 128);
570	}
571	};
572	var _strBuffer = new Uint8Array(3e4);
573	var _maxStrBSize = _strBuffer.length / 3;
574	var _writeVarStringNative = (encoder, str) => {
575	if (str.length < _maxStrBSize) {
576	const written = utf8TextEncoder.encodeInto(str, _strBuffer).written \|\| 0;
577	writeVarUint(encoder, written);
578	for (let i = 0; i < written; i++) {
579	write(encoder, _strBuffer[i]);
580	}
581	} else {
582	writeVarUint8Array(encoder, encodeUtf8(str));
583	}
584	};
585	var _writeVarStringPolyfill = (encoder, str) => {
586	const encodedString = unescape(encodeURIComponent(str));
587	const len = encodedString.length;
588	writeVarUint(encoder, len);
589	for (let i = 0; i < len; i++) {
590	write(
591	encoder,
592	/** @type {number} */
593	encodedString.codePointAt(i)
594	);
595	}
596	};
597	var writeVarString = utf8TextEncoder && /** @type {any} */
598	utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
599	var writeBinaryEncoder = (encoder, append2) => writeUint8Array(encoder, toUint8Array(append2));
600	var writeUint8Array = (encoder, uint8Array) => {
601	const bufferLen = encoder.cbuf.length;
602	const cpos = encoder.cpos;
603	const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
604	const rightCopyLen = uint8Array.length - leftCopyLen;
605	encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
606	encoder.cpos += leftCopyLen;
607	if (rightCopyLen > 0) {
608	encoder.bufs.push(encoder.cbuf);
609	encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
610	encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
611	encoder.cpos = rightCopyLen;
612	}
613	};
614	var writeVarUint8Array = (encoder, uint8Array) => {
615	writeVarUint(encoder, uint8Array.byteLength);
616	writeUint8Array(encoder, uint8Array);
617	};
618	var writeOnDataView = (encoder, len) => {
619	verifyLen(encoder, len);
620	const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
621	encoder.cpos += len;
622	return dview;
623	};
624	var writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
625	var writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
626	var writeBigInt64 = (encoder, num) => (
627	/** @type {any} */
628	writeOnDataView(encoder, 8).setBigInt64(0, num, false)
629	);
630	var floatTestBed = new DataView(new ArrayBuffer(4));
631	var isFloat32 = (num) => {
632	floatTestBed.setFloat32(0, num);
633	return floatTestBed.getFloat32(0) === num;
634	};
635	var writeAny = (encoder, data) => {
636	switch (typeof data) {
637	case "string":
638	write(encoder, 119);
639	writeVarString(encoder, data);
640	break;
641	case "number":
642	if (isInteger(data) && abs(data) <= BITS31) {
643	write(encoder, 125);
644	writeVarInt(encoder, data);
645	} else if (isFloat32(data)) {
646	write(encoder, 124);
647	writeFloat32(encoder, data);
648	} else {
649	write(encoder, 123);
650	writeFloat64(encoder, data);
651	}
652	break;
653	case "bigint":
654	write(encoder, 122);
655	writeBigInt64(encoder, data);
656	break;
657	case "object":
658	if (data === null) {
659	write(encoder, 126);
660	} else if (isArray(data)) {
661	write(encoder, 117);
662	writeVarUint(encoder, data.length);
663	for (let i = 0; i < data.length; i++) {
664	writeAny(encoder, data[i]);
665	}
666	} else if (data instanceof Uint8Array) {
667	write(encoder, 116);
668	writeVarUint8Array(encoder, data);
669	} else {
670	write(encoder, 118);
671	const keys2 = Object.keys(data);
672	writeVarUint(encoder, keys2.length);
673	for (let i = 0; i < keys2.length; i++) {
674	const key = keys2[i];
675	writeVarString(encoder, key);
676	writeAny(encoder, data[key]);
677	}
678	}
679	break;
680	case "boolean":
681	write(encoder, data ? 120 : 121);
682	break;
683	default:
684	write(encoder, 127);
685	}
686	};
687	var RleEncoder = class extends Encoder {
688	/**
689	* @param {function(Encoder, T):void} writer
690	*/
691	constructor(writer) {
692	super();
693	this.w = writer;
694	this.s = null;
695	this.count = 0;
696	}
697	/**
698	* @param {T} v
699	*/
700	write(v) {
701	if (this.s === v) {
702	this.count++;
703	} else {
704	if (this.count > 0) {
705	writeVarUint(this, this.count - 1);
706	}
707	this.count = 1;
708	this.w(this, v);
709	this.s = v;
710	}
711	}
712	};
713	var flushUintOptRleEncoder = (encoder) => {
714	if (encoder.count > 0) {
715	writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s);
716	if (encoder.count > 1) {
717	writeVarUint(encoder.encoder, encoder.count - 2);
718	}
719	}
720	};
721	var UintOptRleEncoder = class {
722	constructor() {
723	this.encoder = new Encoder();
724	this.s = 0;
725	this.count = 0;
726	}
727	/**
728	* @param {number} v
729	*/
730	write(v) {
731	if (this.s === v) {
732	this.count++;
733	} else {
734	flushUintOptRleEncoder(this);
735	this.count = 1;
736	this.s = v;
737	}
738	}
739	/**
740	* Flush the encoded state and transform this to a Uint8Array.
741	*
742	* Note that this should only be called once.
743	*/
744	toUint8Array() {
745	flushUintOptRleEncoder(this);
746	return toUint8Array(this.encoder);
747	}
748	};
749	var flushIntDiffOptRleEncoder = (encoder) => {
750	if (encoder.count > 0) {
751	const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1);
752	writeVarInt(encoder.encoder, encodedDiff);
753	if (encoder.count > 1) {
754	writeVarUint(encoder.encoder, encoder.count - 2);
755	}
756	}
757	};
758	var IntDiffOptRleEncoder = class {
759	constructor() {
760	this.encoder = new Encoder();
761	this.s = 0;
762	this.count = 0;
763	this.diff = 0;
764	}
765	/**
766	* @param {number} v
767	*/
768	write(v) {
769	if (this.diff === v - this.s) {
770	this.s = v;
771	this.count++;
772	} else {
773	flushIntDiffOptRleEncoder(this);
774	this.count = 1;
775	this.diff = v - this.s;
776	this.s = v;
777	}
778	}
779	/**
780	* Flush the encoded state and transform this to a Uint8Array.
781	*
782	* Note that this should only be called once.
783	*/
784	toUint8Array() {
785	flushIntDiffOptRleEncoder(this);
786	return toUint8Array(this.encoder);
787	}
788	};
789	var StringEncoder = class {
790	constructor() {
791	this.sarr = [];
792	this.s = "";
793	this.lensE = new UintOptRleEncoder();
794	}
795	/**
796	* @param {string} string
797	*/
798	write(string) {
799	this.s += string;
800	if (this.s.length > 19) {
801	this.sarr.push(this.s);
802	this.s = "";
803	}
804	this.lensE.write(string.length);
805	}
806	toUint8Array() {
807	const encoder = new Encoder();
808	this.sarr.push(this.s);
809	this.s = "";
810	writeVarString(encoder, this.sarr.join(""));
811	writeUint8Array(encoder, this.lensE.toUint8Array());
812	return toUint8Array(encoder);
813	}
814	};
815
816	// node_modules/lib0/error.js
817	var create3 = (s) => new Error(s);
818	var methodUnimplemented = () => {
819	throw create3("Method unimplemented");
820	};
821	var unexpectedCase = () => {
822	throw create3("Unexpected case");
823	};
824
825	// node_modules/lib0/decoding.js
826	var errorUnexpectedEndOfArray = create3("Unexpected end of array");
827	var errorIntegerOutOfRange = create3("Integer out of Range");
828	var Decoder = class {
829	/**
830	* @param {Uint8Array<Buf>} uint8Array Binary data to decode
831	*/
832	constructor(uint8Array) {
833	this.arr = uint8Array;
834	this.pos = 0;
835	}
836	};
837	var createDecoder = (uint8Array) => new Decoder(uint8Array);
838	var hasContent = (decoder) => decoder.pos !== decoder.arr.length;
839	var readUint8Array = (decoder, len) => {
840	const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
841	decoder.pos += len;
842	return view;
843	};
844	var readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
845	var readUint8 = (decoder) => decoder.arr[decoder.pos++];
846	var readVarUint = (decoder) => {
847	let num = 0;
848	let mult = 1;
849	const len = decoder.arr.length;
850	while (decoder.pos < len) {
851	const r = decoder.arr[decoder.pos++];
852	num = num + (r & BITS7) * mult;
853	mult *= 128;
854	if (r < BIT8) {
855	return num;
856	}
857	if (num > MAX_SAFE_INTEGER) {
858	throw errorIntegerOutOfRange;
859	}
860	}
861	throw errorUnexpectedEndOfArray;
862	};
863	var readVarInt = (decoder) => {
864	let r = decoder.arr[decoder.pos++];
865	let num = r & BITS6;
866	let mult = 64;
867	const sign = (r & BIT7) > 0 ? -1 : 1;
868	if ((r & BIT8) === 0) {
869	return sign * num;
870	}
871	const len = decoder.arr.length;
872	while (decoder.pos < len) {
873	r = decoder.arr[decoder.pos++];
874	num = num + (r & BITS7) * mult;
875	mult *= 128;
876	if (r < BIT8) {
877	return sign * num;
878	}
879	if (num > MAX_SAFE_INTEGER) {
880	throw errorIntegerOutOfRange;
881	}
882	}
883	throw errorUnexpectedEndOfArray;
884	};
885	var _readVarStringPolyfill = (decoder) => {
886	let remainingLen = readVarUint(decoder);
887	if (remainingLen === 0) {
888	return "";
889	} else {
890	let encodedString = String.fromCodePoint(readUint8(decoder));
891	if (--remainingLen < 100) {
892	while (remainingLen--) {
893	encodedString += String.fromCodePoint(readUint8(decoder));
894	}
895	} else {
896	while (remainingLen > 0) {
897	const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
898	const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
899	decoder.pos += nextLen;
900	encodedString += String.fromCodePoint.apply(
901	null,
902	/** @type {any} */
903	bytes
904	);
905	remainingLen -= nextLen;
906	}
907	}
908	return decodeURIComponent(escape(encodedString));
909	}
910	};
911	var _readVarStringNative = (decoder) => (
912	/** @type any */
913	utf8TextDecoder.decode(readVarUint8Array(decoder))
914	);
915	var readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
916	var readFromDataView = (decoder, len) => {
917	const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
918	decoder.pos += len;
919	return dv;
920	};
921	var readFloat32 = (decoder) => readFromDataView(decoder, 4).getFloat32(0, false);
922	var readFloat64 = (decoder) => readFromDataView(decoder, 8).getFloat64(0, false);
923	var readBigInt64 = (decoder) => (
924	/** @type {any} */
925	readFromDataView(decoder, 8).getBigInt64(0, false)
926	);
927	var readAnyLookupTable = [
928	(decoder) => void 0,
929	// CASE 127: undefined
930	(decoder) => null,
931	// CASE 126: null
932	readVarInt,
933	// CASE 125: integer
934	readFloat32,
935	// CASE 124: float32
936	readFloat64,
937	// CASE 123: float64
938	readBigInt64,
939	// CASE 122: bigint
940	(decoder) => false,
941	// CASE 121: boolean (false)
942	(decoder) => true,
943	// CASE 120: boolean (true)
944	readVarString,
945	// CASE 119: string
946	(decoder) => {
947	const len = readVarUint(decoder);
948	const obj = {};
949	for (let i = 0; i < len; i++) {
950	const key = readVarString(decoder);
951	obj[key] = readAny(decoder);
952	}
953	return obj;
954	},
955	(decoder) => {
956	const len = readVarUint(decoder);
957	const arr = [];
958	for (let i = 0; i < len; i++) {
959	arr.push(readAny(decoder));
960	}
961	return arr;
962	},
963	readVarUint8Array
964	// CASE 116: Uint8Array
965	];
966	var readAny = (decoder) => readAnyLookupTable[127 - readUint8(decoder)](decoder);
967	var RleDecoder = class extends Decoder {
968	/**
969	* @param {Uint8Array} uint8Array
970	* @param {function(Decoder):T} reader
971	*/
972	constructor(uint8Array, reader) {
973	super(uint8Array);
974	this.reader = reader;
975	this.s = null;
976	this.count = 0;
977	}
978	read() {
979	if (this.count === 0) {
980	this.s = this.reader(this);
981	if (hasContent(this)) {
982	this.count = readVarUint(this) + 1;
983	} else {
984	this.count = -1;
985	}
986	}
987	this.count--;
988	return (
989	/** @type {T} */
990	this.s
991	);
992	}
993	};
994	var UintOptRleDecoder = class extends Decoder {
995	/**
996	* @param {Uint8Array} uint8Array
997	*/
998	constructor(uint8Array) {
999	super(uint8Array);
1000	this.s = 0;
1001	this.count = 0;
1002	}
1003	read() {
1004	if (this.count === 0) {
1005	this.s = readVarInt(this);
1006	const isNegative = isNegativeZero(this.s);
1007	this.count = 1;
1008	if (isNegative) {
1009	this.s = -this.s;
1010	this.count = readVarUint(this) + 2;
1011	}
1012	}
1013	this.count--;
1014	return (
1015	/** @type {number} */
1016	this.s
1017	);
1018	}
1019	};
1020	var IntDiffOptRleDecoder = class extends Decoder {
1021	/**
1022	* @param {Uint8Array} uint8Array
1023	*/
1024	constructor(uint8Array) {
1025	super(uint8Array);
1026	this.s = 0;
1027	this.count = 0;
1028	this.diff = 0;
1029	}
1030	/**
1031	* @return {number}
1032	*/
1033	read() {
1034	if (this.count === 0) {
1035	const diff = readVarInt(this);
1036	const hasCount = diff & 1;
1037	this.diff = floor(diff / 2);
1038	this.count = 1;
1039	if (hasCount) {
1040	this.count = readVarUint(this) + 2;
1041	}
1042	}
1043	this.s += this.diff;
1044	this.count--;
1045	return this.s;
1046	}
1047	};
1048	var StringDecoder = class {
1049	/**
1050	* @param {Uint8Array} uint8Array
1051	*/
1052	constructor(uint8Array) {
1053	this.decoder = new UintOptRleDecoder(uint8Array);
1054	this.str = readVarString(this.decoder);
1055	this.spos = 0;
1056	}
1057	/**
1058	* @return {string}
1059	*/
1060	read() {
1061	const end = this.spos + this.decoder.read();
1062	const res = this.str.slice(this.spos, end);
1063	this.spos = end;
1064	return res;
1065	}
1066	};
1067
1068	// node_modules/lib0/webcrypto.js
1069	var subtle = crypto.subtle;
1070	var getRandomValues = crypto.getRandomValues.bind(crypto);
1071
1072	// node_modules/lib0/random.js
1073	var uint32 = () => getRandomValues(new Uint32Array(1))[0];
1074	var uuidv4Template = "10000000-1000-4000-8000" + -1e11;
1075	var uuidv4 = () => uuidv4Template.replace(
1076	/[018]/g,
1077	/** @param {number} c */
1078	(c) => (c ^ uint32() & 15 >> c / 4).toString(16)
1079	);
1080
1081	// node_modules/lib0/time.js
1082	var getUnixTime = Date.now;
1083
1084	// node_modules/lib0/promise.js
1085	var create4 = (f) => (
1086	/** @type {Promise<T>} */
1087	new Promise(f)
1088	);
1089	var all = Promise.all.bind(Promise);
1090
1091	// node_modules/lib0/conditions.js
1092	var undefinedToNull = (v) => v === void 0 ? null : v;
1093
1094	// node_modules/lib0/storage.js
1095	var VarStoragePolyfill = class {
1096	constructor() {
1097	this.map = /* @__PURE__ */ new Map();
1098	}
1099	/**
1100	* @param {string} key
1101	* @param {any} newValue
1102	*/
1103	setItem(key, newValue) {
1104	this.map.set(key, newValue);
1105	}
1106	/**
1107	* @param {string} key
1108	*/
1109	getItem(key) {
1110	return this.map.get(key);
1111	}
1112	};
1113	var _localStorage = new VarStoragePolyfill();
1114	var usePolyfill = true;
1115	try {
1116	if (typeof localStorage !== "undefined" && localStorage) {
1117	_localStorage = localStorage;
1118	usePolyfill = false;
1119	}
1120	} catch (e) {
1121	}
1122	var varStorage = _localStorage;
1123
1124	// node_modules/lib0/trait/equality.js
1125	var EqualityTraitSymbol = /* @__PURE__ */ Symbol("Equality");
1126	var equals = (a, b) => a === b \|\| !!a?.[EqualityTraitSymbol]?.(b) \|\| false;
1127
1128	// node_modules/lib0/object.js
1129	var isObject = (o) => typeof o === "object";
1130	var assign = Object.assign;
1131	var keys = Object.keys;
1132	var forEach = (obj, f) => {
1133	for (const key in obj) {
1134	f(obj[key], key);
1135	}
1136	};
1137	var size = (obj) => keys(obj).length;
1138	var isEmpty = (obj) => {
1139	for (const _k in obj) {
1140	return false;
1141	}
1142	return true;
1143	};
1144	var every2 = (obj, f) => {
1145	for (const key in obj) {
1146	if (!f(obj[key], key)) {
1147	return false;
1148	}
1149	}
1150	return true;
1151	};
1152	var hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
1153	var equalFlat = (a, b) => a === b \|\| size(a) === size(b) && every2(a, (val, key) => (val !== void 0 \|\| hasProperty(b, key)) && equals(b[key], val));
1154	var freeze = Object.freeze;
1155	var deepFreeze = (o) => {
1156	for (const key in o) {
1157	const c = o[key];
1158	if (typeof c === "object" \|\| typeof c === "function") {
1159	deepFreeze(o[key]);
1160	}
1161	}
1162	return freeze(o);
1163	};
1164
1165	// node_modules/lib0/function.js
1166	var callAll = (fs, args2, i = 0) => {
1167	try {
1168	for (; i < fs.length; i++) {
1169	fs[i](...args2);
1170	}
1171	} finally {
1172	if (i < fs.length) {
1173	callAll(fs, args2, i + 1);
1174	}
1175	}
1176	};
1177	var id = (a) => a;
1178	var equalityDeep = (a, b) => {
1179	if (a === b) {
1180	return true;
1181	}
1182	if (a == null \|\| b == null \|\| a.constructor !== b.constructor && (a.constructor \|\| Object) !== (b.constructor \|\| Object)) {
1183	return false;
1184	}
1185	if (a[EqualityTraitSymbol] != null) {
1186	return a[EqualityTraitSymbol](b);
1187	}
1188	switch (a.constructor) {
1189	case ArrayBuffer:
1190	a = new Uint8Array(a);
1191	b = new Uint8Array(b);
1192	// eslint-disable-next-line no-fallthrough
1193	case Uint8Array: {
1194	if (a.byteLength !== b.byteLength) {
1195	return false;
1196	}
1197	for (let i = 0; i < a.length; i++) {
1198	if (a[i] !== b[i]) {
1199	return false;
1200	}
1201	}
1202	break;
1203	}
1204	case Set: {
1205	if (a.size !== b.size) {
1206	return false;
1207	}
1208	for (const value of a) {
1209	if (!b.has(value)) {
1210	return false;
1211	}
1212	}
1213	break;
1214	}
1215	case Map: {
1216	if (a.size !== b.size) {
1217	return false;
1218	}
1219	for (const key of a.keys()) {
1220	if (!b.has(key) \|\| !equalityDeep(a.get(key), b.get(key))) {
1221	return false;
1222	}
1223	}
1224	break;
1225	}
1226	case void 0:
1227	case Object:
1228	if (size(a) !== size(b)) {
1229	return false;
1230	}
1231	for (const key in a) {
1232	if (!hasProperty(a, key) \|\| !equalityDeep(a[key], b[key])) {
1233	return false;
1234	}
1235	}
1236	break;
1237	case Array:
1238	if (a.length !== b.length) {
1239	return false;
1240	}
1241	for (let i = 0; i < a.length; i++) {
1242	if (!equalityDeep(a[i], b[i])) {
1243	return false;
1244	}
1245	}
1246	break;
1247	default:
1248	return false;
1249	}
1250	return true;
1251	};
1252	var isOneOf = (value, options) => options.includes(value);
1253
1254	// node_modules/lib0/environment.js
1255	var isNode = typeof process !== "undefined" && process.release && /node\|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
1256	var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && !isNode;
1257	var isMac = typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
1258	var params;
1259	var args = [];
1260	var computeParams = () => {
1261	if (params === void 0) {
1262	if (isNode) {
1263	params = create();
1264	const pargs = process.argv;
1265	let currParamName = null;
1266	for (let i = 0; i < pargs.length; i++) {
1267	const parg = pargs[i];
1268	if (parg[0] === "-") {
1269	if (currParamName !== null) {
1270	params.set(currParamName, "");
1271	}
1272	currParamName = parg;
1273	} else {
1274	if (currParamName !== null) {
1275	params.set(currParamName, parg);
1276	currParamName = null;
1277	} else {
1278	args.push(parg);
1279	}
1280	}
1281	}
1282	if (currParamName !== null) {
1283	params.set(currParamName, "");
1284	}
1285	} else if (typeof location === "object") {
1286	params = create();
1287	(location.search \|\| "?").slice(1).split("&").forEach((kv) => {
1288	if (kv.length !== 0) {
1289	const [key, value] = kv.split("=");
1290	params.set(`--${fromCamelCase(key, "-")}`, value);
1291	params.set(`-${fromCamelCase(key, "-")}`, value);
1292	}
1293	});
1294	} else {
1295	params = create();
1296	}
1297	}
1298	return params;
1299	};
1300	var hasParam = (name) => computeParams().has(name);
1301	var getVariable = (name) => isNode ? undefinedToNull(process.env[name.toUpperCase().replaceAll("-", "_")]) : undefinedToNull(varStorage.getItem(name));
1302	var hasConf = (name) => hasParam("--" + name) \|\| getVariable(name) !== null;
1303	var production = hasConf("production");
1304	var forceColor = isNode && isOneOf(process.env.FORCE_COLOR, ["true", "1", "2"]);
1305	var supportsColor = forceColor \|\| !hasParam("--no-colors") && // @todo deprecate --no-colors
1306	!hasConf("no-color") && (!isNode \|\| process.stdout.isTTY) && (!isNode \|\| hasParam("--color") \|\| getVariable("COLORTERM") !== null \|\| (getVariable("TERM") \|\| "").includes("color"));
1307
1308	// node_modules/lib0/buffer.js
1309	var createUint8ArrayFromLen = (len) => new Uint8Array(len);
1310	var createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length2) => new Uint8Array(buffer, byteOffset, length2);
1311	var toBase64Browser = (bytes) => {
1312	let s = "";
1313	for (let i = 0; i < bytes.byteLength; i++) {
1314	s += fromCharCode(bytes[i]);
1315	}
1316	return btoa(s);
1317	};
1318	var toBase64Node = (bytes) => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
1319	var fromBase64Browser = (s) => {
1320	const a = atob(s);
1321	const bytes = createUint8ArrayFromLen(a.length);
1322	for (let i = 0; i < a.length; i++) {
1323	bytes[i] = a.charCodeAt(i);
1324	}
1325	return bytes;
1326	};
1327	var fromBase64Node = (s) => {
1328	const buf = Buffer.from(s, "base64");
1329	return createUint8ArrayViewFromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength);
1330	};
1331	var toBase64 = isBrowser ? toBase64Browser : toBase64Node;
1332	var fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
1333	var copyUint8Array = (uint8Array) => {
1334	const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
1335	newBuf.set(uint8Array);
1336	return newBuf;
1337	};
1338
1339	// node_modules/lib0/pair.js
1340	var Pair = class {
1341	/**
1342	* @param {L} left
1343	* @param {R} right
1344	*/
1345	constructor(left, right) {
1346	this.left = left;
1347	this.right = right;
1348	}
1349	};
1350	var create5 = (left, right) => new Pair(left, right);
1351
1352	// node_modules/lib0/prng.js
1353	var bool = (gen) => gen.next() >= 0.5;
1354	var int53 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
1355	var int32 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
1356	var int31 = (gen, min2, max2) => int32(gen, min2, max2);
1357	var letter = (gen) => fromCharCode(int31(gen, 97, 122));
1358	var word = (gen, minLen = 0, maxLen = 20) => {
1359	const len = int31(gen, minLen, maxLen);
1360	let str = "";
1361	for (let i = 0; i < len; i++) {
1362	str += letter(gen);
1363	}
1364	return str;
1365	};
1366	var oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
1367
1368	// node_modules/lib0/schema.js
1369	var schemaSymbol = /* @__PURE__ */ Symbol("0schema");
1370	var ValidationError = class {
1371	constructor() {
1372	this._rerrs = [];
1373	}
1374	/**
1375	* @param {string?} path
1376	* @param {string} expected
1377	* @param {string} has
1378	* @param {string?} message
1379	*/
1380	extend(path, expected, has, message = null) {
1381	this._rerrs.push({ path, expected, has, message });
1382	}
1383	toString() {
1384	const s = [];
1385	for (let i = this._rerrs.length - 1; i > 0; i--) {
1386	const r = this._rerrs[i];
1387	s.push(repeat(" ", (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ""}${r.has} doesn't match ${r.expected}. ${r.message}`);
1388	}
1389	return s.join("\n");
1390	}
1391	};
1392	var shapeExtends = (a, b) => {
1393	if (a === b) return true;
1394	if (a == null \|\| b == null \|\| a.constructor !== b.constructor) return false;
1395	if (a[EqualityTraitSymbol]) return equals(a, b);
1396	if (isArray(a)) {
1397	return every(
1398	a,
1399	(aitem) => some(b, (bitem) => shapeExtends(aitem, bitem))
1400	);
1401	} else if (isObject(a)) {
1402	return every2(
1403	a,
1404	(aitem, akey) => shapeExtends(aitem, b[akey])
1405	);
1406	}
1407	return false;
1408	};
1409	var Schema = class {
1410	// this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
1411	/**
1412	* If true, the more things are added to the shape the more objects this schema will accept (e.g.
1413	* union). By default, the more objects are added, the the fewer objects this schema will accept.
1414	* @protected
1415	*/
1416	static _dilutes = false;
1417	/**
1418	* @param {Schema<any>} other
1419	*/
1420	extends(other) {
1421	let [a, b] = [
1422	/** @type {any} */
1423	this.shape,
1424	/** @type {any} */
1425	other.shape
1426	];
1427	if (
1428	/** @type {typeof Schema<any>} */
1429	this.constructor._dilutes
1430	) [b, a] = [a, b];
1431	return shapeExtends(a, b);
1432	}
1433	/**
1434	* Overwrite this when necessary. By default, we only check the `shape` property which every shape
1435	* should have.
1436	* @param {Schema<any>} other
1437	*/
1438	equals(other) {
1439	return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
1440	}
1441	[schemaSymbol]() {
1442	return true;
1443	}
1444	/**
1445	* @param {object} other
1446	*/
1447	[EqualityTraitSymbol](other) {
1448	return this.equals(
1449	/** @type {any} */
1450	other
1451	);
1452	}
1453	/**
1454	* Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
1455	* Schema. Validate will check the structure of the parameter and return true iff the instance
1456	* really is an instance of Schema.
1457	*
1458	* @param {T} o
1459	* @return {boolean}
1460	*/
1461	validate(o) {
1462	return this.check(o);
1463	}
1464	/* c8 ignore start */
1465	/**
1466	* Similar to validate, but this method accepts untyped parameters.
1467	*
1468	* @param {any} _o
1469	* @param {ValidationError} [_err]
1470	* @return {_o is T}
1471	*/
1472	check(_o, _err) {
1473	methodUnimplemented();
1474	}
1475	/* c8 ignore stop */
1476	/**
1477	* @type {Schema<T?>}
1478	*/
1479	get nullable() {
1480	return $union(this, $null);
1481	}
1482	/**
1483	* @type {$Optional<Schema<T>>}
1484	*/
1485	get optional() {
1486	return new $Optional(
1487	/** @type {Schema<T>} */
1488	this
1489	);
1490	}
1491	/**
1492	* Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
1493	* Use this if you know that the type is of a specific type and you just want to convince the type
1494	* system.
1495	*
1496	* Do not rely on these error messages!
1497	* Performs an assertion check only if not in a production environment.
1498	*
1499	* @template OO
1500	* @param {OO} o
1501	* @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
1502	*/
1503	cast(o) {
1504	assert(o, this);
1505	return (
1506	/** @type {any} */
1507	o
1508	);
1509	}
1510	/**
1511	* EXPECTO PATRONUM!! 🪄
1512	* This function protects against type errors. Though it may not work in the real world.
1513	*
1514	* "After all this time?"
1515	* "Always." - Snape, talking about type safety
1516	*
1517	* Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
1518	* Use this if you know that the type is of a specific type and you just want to convince the type
1519	* system.
1520	*
1521	* Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
1522	*
1523	* Do not rely on these error messages!
1524	* Performs an assertion check if not in a production environment.
1525	*
1526	* @param {T} o
1527	* @return {o extends T ? T : never}
1528	*/
1529	expect(o) {
1530	assert(o, this);
1531	return o;
1532	}
1533	};
1534	var $ConstructedBy = class extends Schema {
1535	/**
1536	* @param {C} c
1537	* @param {((o:Instance<C>)=>boolean)\|null} check
1538	*/
1539	constructor(c, check) {
1540	super();
1541	this.shape = c;
1542	this._c = check;
1543	}
1544	/**
1545	* @param {any} o
1546	* @param {ValidationError} [err]
1547	* @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
1548	*/
1549	check(o, err = void 0) {
1550	const c = o?.constructor === this.shape && (this._c == null \|\| this._c(o));
1551	!c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
1552	return c;
1553	}
1554	};
1555	var $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
1556	var $$constructedBy = $constructedBy($ConstructedBy);
1557	var $Custom = class extends Schema {
1558	/**
1559	* @param {(o:any) => boolean} check
1560	*/
1561	constructor(check) {
1562	super();
1563	this.shape = check;
1564	}
1565	/**
1566	* @param {any} o
1567	* @param {ValidationError} err
1568	* @return {o is any}
1569	*/
1570	check(o, err) {
1571	const c = this.shape(o);
1572	!c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
1573	return c;
1574	}
1575	};
1576	var $custom = (check) => new $Custom(check);
1577	var $$custom = $constructedBy($Custom);
1578	var $Literal = class extends Schema {
1579	/**
1580	* @param {Array<T>} literals
1581	*/
1582	constructor(literals) {
1583	super();
1584	this.shape = literals;
1585	}
1586	/**
1587	*
1588	* @param {any} o
1589	* @param {ValidationError} [err]
1590	* @return {o is T}
1591	*/
1592	check(o, err) {
1593	const c = this.shape.some((a) => a === o);
1594	!c && err?.extend(null, this.shape.join(" \| "), o.toString());
1595	return c;
1596	}
1597	};
1598	var $literal = (...literals) => new $Literal(literals);
1599	var $$literal = $constructedBy($Literal);
1600	var _regexEscape = (
1601	/** @type {any} */
1602	RegExp.escape \|\| /** @type {(str:string) => string} */
1603	((str) => str.replace(/[().\|&,$^[\]]/g, (s) => "\\" + s))
1604	);
1605	var _schemaStringTemplateToRegex = (s) => {
1606	if ($string.check(s)) {
1607	return [_regexEscape(s)];
1608	}
1609	if ($$literal.check(s)) {
1610	return (
1611	/** @type {Array<string\|number>} */
1612	s.shape.map((v) => v + "")
1613	);
1614	}
1615	if ($$number.check(s)) {
1616	return ["[+-]?\\d+.?\\d*"];
1617	}
1618	if ($$string.check(s)) {
1619	return [".*"];
1620	}
1621	if ($$union.check(s)) {
1622	return s.shape.map(_schemaStringTemplateToRegex).flat(1);
1623	}
1624	unexpectedCase();
1625	};
1626	var $StringTemplate = class extends Schema {
1627	/**
1628	* @param {T} shape
1629	*/
1630	constructor(shape) {
1631	super();
1632	this.shape = shape;
1633	this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("\|")})`).join("") + "$");
1634	}
1635	/**
1636	* @param {any} o
1637	* @param {ValidationError} [err]
1638	* @return {o is CastStringTemplateArgsToTemplate<T>}
1639	*/
1640	check(o, err) {
1641	const c = this._r.exec(o) != null;
1642	!c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
1643	return c;
1644	}
1645	};
1646	var $$stringTemplate = $constructedBy($StringTemplate);
1647	var isOptionalSymbol = /* @__PURE__ */ Symbol("optional");
1648	var $Optional = class extends Schema {
1649	/**
1650	* @param {S} shape
1651	*/
1652	constructor(shape) {
1653	super();
1654	this.shape = shape;
1655	}
1656	/**
1657	* @param {any} o
1658	* @param {ValidationError} [err]
1659	* @return {o is (Unwrap<S>\|undefined)}
1660	*/
1661	check(o, err) {
1662	const c = o === void 0 \|\| this.shape.check(o);
1663	!c && err?.extend(null, "undefined (optional)", "()");
1664	return c;
1665	}
1666	get [isOptionalSymbol]() {
1667	return true;
1668	}
1669	};
1670	var $$optional = $constructedBy($Optional);
1671	var $Never = class extends Schema {
1672	/**
1673	* @param {any} _o
1674	* @param {ValidationError} [err]
1675	* @return {_o is never}
1676	*/
1677	check(_o, err) {
1678	err?.extend(null, "never", typeof _o);
1679	return false;
1680	}
1681	};
1682	var $never = new $Never();
1683	var $$never = $constructedBy($Never);
1684	var $Object = class _$Object extends Schema {
1685	/**
1686	* @param {S} shape
1687	* @param {boolean} partial
1688	*/
1689	constructor(shape, partial = false) {
1690	super();
1691	this.shape = shape;
1692	this._isPartial = partial;
1693	}
1694	static _dilutes = true;
1695	/**
1696	* @type {Schema<Partial<$ObjectToType<S>>>}
1697	*/
1698	get partial() {
1699	return new _$Object(this.shape, true);
1700	}
1701	/**
1702	* @param {any} o
1703	* @param {ValidationError} err
1704	* @return {o is $ObjectToType<S>}
1705	*/
1706	check(o, err) {
1707	if (o == null) {
1708	err?.extend(null, "object", "null");
1709	return false;
1710	}
1711	return every2(this.shape, (vv, vk) => {
1712	const c = this._isPartial && !hasProperty(o, vk) \|\| vv.check(o[vk], err);
1713	!c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
1714	return c;
1715	});
1716	}
1717	};
1718	var $object = (def) => (
1719	/** @type {any} */
1720	new $Object(def)
1721	);
1722	var $$object = $constructedBy($Object);
1723	var $objectAny = $custom((o) => o != null && (o.constructor === Object \|\| o.constructor == null));
1724	var $Record = class extends Schema {
1725	/**
1726	* @param {Keys} keys
1727	* @param {Values} values
1728	*/
1729	constructor(keys2, values) {
1730	super();
1731	this.shape = {
1732	keys: keys2,
1733	values
1734	};
1735	}
1736	/**
1737	* @param {any} o
1738	* @param {ValidationError} err
1739	* @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
1740	*/
1741	check(o, err) {
1742	return o != null && every2(o, (vv, vk) => {
1743	const ck = this.shape.keys.check(vk, err);
1744	!ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
1745	return ck && this.shape.values.check(vv, err);
1746	});
1747	}
1748	};
1749	var $record = (keys2, values) => new $Record(keys2, values);
1750	var $$record = $constructedBy($Record);
1751	var $Tuple = class extends Schema {
1752	/**
1753	* @param {S} shape
1754	*/
1755	constructor(shape) {
1756	super();
1757	this.shape = shape;
1758	}
1759	/**
1760	* @param {any} o
1761	* @param {ValidationError} err
1762	* @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
1763	*/
1764	check(o, err) {
1765	return o != null && every2(this.shape, (vv, vk) => {
1766	const c = (
1767	/** @type {Schema<any>} */
1768	vv.check(o[vk], err)
1769	);
1770	!c && err?.extend(vk.toString(), "Tuple", typeof vv);
1771	return c;
1772	});
1773	}
1774	};
1775	var $tuple = (...def) => new $Tuple(def);
1776	var $$tuple = $constructedBy($Tuple);
1777	var $Array = class extends Schema {
1778	/**
1779	* @param {Array<S>} v
1780	*/
1781	constructor(v) {
1782	super();
1783	this.shape = v.length === 1 ? v[0] : new $Union(v);
1784	}
1785	/**
1786	* @param {any} o
1787	* @param {ValidationError} [err]
1788	* @return {o is Array<S extends Schema<infer T> ? T : never>} o
1789	*/
1790	check(o, err) {
1791	const c = isArray(o) && every(o, (oi) => this.shape.check(oi));
1792	!c && err?.extend(null, "Array", "");
1793	return c;
1794	}
1795	};
1796	var $array = (...def) => new $Array(def);
1797	var $$array = $constructedBy($Array);
1798	var $arrayAny = $custom((o) => isArray(o));
1799	var $InstanceOf = class extends Schema {
1800	/**
1801	* @param {new (...args:any) => T} constructor
1802	* @param {((o:T) => boolean)\|null} check
1803	*/
1804	constructor(constructor, check) {
1805	super();
1806	this.shape = constructor;
1807	this._c = check;
1808	}
1809	/**
1810	* @param {any} o
1811	* @param {ValidationError} err
1812	* @return {o is T}
1813	*/
1814	check(o, err) {
1815	const c = o instanceof this.shape && (this._c == null \|\| this._c(o));
1816	!c && err?.extend(null, this.shape.name, o?.constructor.name);
1817	return c;
1818	}
1819	};
1820	var $instanceOf = (c, check = null) => new $InstanceOf(c, check);
1821	var $$instanceOf = $constructedBy($InstanceOf);
1822	var $$schema = $instanceOf(Schema);
1823	var $Lambda = class extends Schema {
1824	/**
1825	* @param {Args} args
1826	*/
1827	constructor(args2) {
1828	super();
1829	this.len = args2.length - 1;
1830	this.args = $tuple(...args2.slice(-1));
1831	this.res = args2[this.len];
1832	}
1833	/**
1834	* @param {any} f
1835	* @param {ValidationError} err
1836	* @return {f is _LArgsToLambdaDef<Args>}
1837	*/
1838	check(f, err) {
1839	const c = f.constructor === Function && f.length <= this.len;
1840	!c && err?.extend(null, "function", typeof f);
1841	return c;
1842	}
1843	};
1844	var $$lambda = $constructedBy($Lambda);
1845	var $function = $custom((o) => typeof o === "function");
1846	var $Intersection = class extends Schema {
1847	/**
1848	* @param {T} v
1849	*/
1850	constructor(v) {
1851	super();
1852	this.shape = v;
1853	}
1854	/**
1855	* @param {any} o
1856	* @param {ValidationError} [err]
1857	* @return {o is Intersect<UnwrapArray<T>>}
1858	*/
1859	check(o, err) {
1860	const c = every(this.shape, (check) => check.check(o, err));
1861	!c && err?.extend(null, "Intersectinon", typeof o);
1862	return c;
1863	}
1864	};
1865	var $$intersect = $constructedBy($Intersection, (o) => o.shape.length > 0);
1866	var $Union = class extends Schema {
1867	static _dilutes = true;
1868	/**
1869	* @param {Array<Schema<S>>} v
1870	*/
1871	constructor(v) {
1872	super();
1873	this.shape = v;
1874	}
1875	/**
1876	* @param {any} o
1877	* @param {ValidationError} [err]
1878	* @return {o is S}
1879	*/
1880	check(o, err) {
1881	const c = some(this.shape, (vv) => vv.check(o, err));
1882	err?.extend(null, "Union", typeof o);
1883	return c;
1884	}
1885	};
1886	var $union = (...schemas) => schemas.findIndex(($s) => $$union.check($s)) >= 0 ? $union(...schemas.map(($s) => $($s)).map(($s) => $$union.check($s) ? $s.shape : [$s]).flat(1)) : schemas.length === 1 ? schemas[0] : new $Union(schemas);
1887	var $$union = (
1888	/** @type {Schema<$Union<any>>} */
1889	$constructedBy($Union)
1890	);
1891	var _t = () => true;
1892	var $any = $custom(_t);
1893	var $$any = (
1894	/** @type {Schema<Schema<any>>} */
1895	$constructedBy($Custom, (o) => o.shape === _t)
1896	);
1897	var $bigint = $custom((o) => typeof o === "bigint");
1898	var $$bigint = (
1899	/** @type {Schema<Schema<BigInt>>} */
1900	$custom((o) => o === $bigint)
1901	);
1902	var $symbol = $custom((o) => typeof o === "symbol");
1903	var $$symbol = (
1904	/** @type {Schema<Schema<Symbol>>} */
1905	$custom((o) => o === $symbol)
1906	);
1907	var $number = $custom((o) => typeof o === "number");
1908	var $$number = (
1909	/** @type {Schema<Schema<number>>} */
1910	$custom((o) => o === $number)
1911	);
1912	var $string = $custom((o) => typeof o === "string");
1913	var $$string = (
1914	/** @type {Schema<Schema<string>>} */
1915	$custom((o) => o === $string)
1916	);
1917	var $boolean = $custom((o) => typeof o === "boolean");
1918	var $$boolean = (
1919	/** @type {Schema<Schema<Boolean>>} */
1920	$custom((o) => o === $boolean)
1921	);
1922	var $undefined = $literal(void 0);
1923	var $$undefined = (
1924	/** @type {Schema<Schema<undefined>>} */
1925	$constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0)
1926	);
1927	var $void = $literal(void 0);
1928	var $null = $literal(null);
1929	var $$null = (
1930	/** @type {Schema<Schema<null>>} */
1931	$constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null)
1932	);
1933	var $uint8Array = $constructedBy(Uint8Array);
1934	var $$uint8Array = (
1935	/** @type {Schema<Schema<Uint8Array>>} */
1936	$constructedBy($ConstructedBy, (o) => o.shape === Uint8Array)
1937	);
1938	var $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
1939	var $json = (() => {
1940	const $jsonArr = (
1941	/** @type {$Array<$any>} */
1942	$array($any)
1943	);
1944	const $jsonRecord = (
1945	/** @type {$Record<$string,$any>} */
1946	$record($string, $any)
1947	);
1948	const $json2 = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
1949	$jsonArr.shape = $json2;
1950	$jsonRecord.shape.values = $json2;
1951	return $json2;
1952	})();
1953	var $ = (o) => {
1954	if ($$schema.check(o)) {
1955	return (
1956	/** @type {any} */
1957	o
1958	);
1959	} else if ($objectAny.check(o)) {
1960	const o2 = {};
1961	for (const k in o) {
1962	o2[k] = $(o[k]);
1963	}
1964	return (
1965	/** @type {any} */
1966	$object(o2)
1967	);
1968	} else if ($arrayAny.check(o)) {
1969	return (
1970	/** @type {any} */
1971	$union(...o.map($))
1972	);
1973	} else if ($primitive.check(o)) {
1974	return (
1975	/** @type {any} */
1976	$literal(o)
1977	);
1978	} else if ($function.check(o)) {
1979	return (
1980	/** @type {any} */
1981	$constructedBy(
1982	/** @type {any} */
1983	o
1984	)
1985	);
1986	}
1987	unexpectedCase();
1988	};
1989	var assert = production ? () => {
1990	} : (o, schema) => {
1991	const err = new ValidationError();
1992	if (!schema.check(o, err)) {
1993	throw create3(`Expected value to be of type ${schema.constructor.name}.
1994	${err.toString()}`);
1995	}
1996	};
1997	var PatternMatcher = class {
1998	/**
1999	* @param {Schema<State>} [$state]
2000	*/
2001	constructor($state) {
2002	this.patterns = [];
2003	this.$state = $state;
2004	}
2005	/**
2006	* @template P
2007	* @template R
2008	* @param {P} pattern
2009	* @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
2010	* @return {PatternMatcher<State,Patterns\|Pattern<Unwrap<ReadSchema<P>>,R>>}
2011	*/
2012	if(pattern, handler) {
2013	this.patterns.push({ if: $(pattern), h: handler });
2014	return this;
2015	}
2016	/**
2017	* @template R
2018	* @param {(o:any,s:State)=>R} h
2019	*/
2020	else(h) {
2021	return this.if($any, h);
2022	}
2023	/**
2024	* @return {State extends undefined
2025	* ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
2026	* : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
2027	*/
2028	done() {
2029	return (
2030	/** @type {any} */
2031	(o, s) => {
2032	for (let i = 0; i < this.patterns.length; i++) {
2033	const p = this.patterns[i];
2034	if (p.if.check(o)) {
2035	return p.h(o, s);
2036	}
2037	}
2038	throw create3("Unhandled pattern");
2039	}
2040	);
2041	}
2042	};
2043	var match = (state) => new PatternMatcher(
2044	/** @type {any} */
2045	state
2046	);
2047	var _random = (
2048	/** @type {any} */
2049	match(
2050	/** @type {Schema<prng.PRNG>} */
2051	$any
2052	).if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))).if($$union, (o, gen) => random(gen, oneOf(gen, o.shape))).if($$object, (o, gen) => {
2053	const res = {};
2054	for (const k in o.shape) {
2055	let prop = o.shape[k];
2056	if ($$optional.check(prop)) {
2057	if (bool(gen)) {
2058	continue;
2059	}
2060	prop = prop.shape;
2061	}
2062	res[k] = _random(prop, gen);
2063	}
2064	return res;
2065	}).if($$array, (o, gen) => {
2066	const arr = [];
2067	const n = int32(gen, 0, 42);
2068	for (let i = 0; i < n; i++) {
2069	arr.push(random(gen, o.shape));
2070	}
2071	return arr;
2072	}).if($$literal, (o, gen) => {
2073	return oneOf(gen, o.shape);
2074	}).if($$null, (o, gen) => {
2075	return null;
2076	}).if($$lambda, (o, gen) => {
2077	const res = random(gen, o.res);
2078	return () => res;
2079	}).if($$any, (o, gen) => random(gen, oneOf(gen, [
2080	$number,
2081	$string,
2082	$null,
2083	$undefined,
2084	$bigint,
2085	$boolean,
2086	$array($number),
2087	$record($union("a", "b", "c"), $number)
2088	]))).if($$record, (o, gen) => {
2089	const res = {};
2090	const keysN = int53(gen, 0, 3);
2091	for (let i = 0; i < keysN; i++) {
2092	const key = random(gen, o.shape.keys);
2093	const val = random(gen, o.shape.values);
2094	res[key] = val;
2095	}
2096	return res;
2097	}).done()
2098	);
2099	var random = (gen, schema) => (
2100	/** @type {any} */
2101	_random($(schema), gen)
2102	);
2103
2104	// node_modules/lib0/dom.js
2105	var doc = (
2106	/** @type {Document} */
2107	typeof document !== "undefined" ? document : {}
2108	);
2109	var $fragment = $custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
2110	var domParser = (
2111	/** @type {DOMParser} */
2112	typeof DOMParser !== "undefined" ? new DOMParser() : null
2113	);
2114	var $element = $custom((el) => el.nodeType === ELEMENT_NODE);
2115	var $text = $custom((el) => el.nodeType === TEXT_NODE);
2116	var mapToStyleString = (m) => map(m, (value, key) => `${key}:${value};`).join("");
2117	var ELEMENT_NODE = doc.ELEMENT_NODE;
2118	var TEXT_NODE = doc.TEXT_NODE;
2119	var CDATA_SECTION_NODE = doc.CDATA_SECTION_NODE;
2120	var COMMENT_NODE = doc.COMMENT_NODE;
2121	var DOCUMENT_NODE = doc.DOCUMENT_NODE;
2122	var DOCUMENT_TYPE_NODE = doc.DOCUMENT_TYPE_NODE;
2123	var DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
2124	var $node = $custom((el) => el.nodeType === DOCUMENT_NODE);
2125
2126	// node_modules/lib0/symbol.js
2127	var create6 = Symbol;
2128
2129	// node_modules/lib0/logging.common.js
2130	var BOLD = create6();
2131	var UNBOLD = create6();
2132	var BLUE = create6();
2133	var GREY = create6();
2134	var GREEN = create6();
2135	var RED = create6();
2136	var PURPLE = create6();
2137	var ORANGE = create6();
2138	var UNCOLOR = create6();
2139	var computeNoColorLoggingArgs = (args2) => {
2140	if (args2.length === 1 && args2[0]?.constructor === Function) {
2141	args2 = /** @type {Array<string\|Symbol\|Object\|number>} */
2142	/** @type {[function]} */
2143	args2[0]();
2144	}
2145	const strBuilder = [];
2146	const logArgs = [];
2147	let i = 0;
2148	for (; i < args2.length; i++) {
2149	const arg = args2[i];
2150	if (arg === void 0) {
2151	break;
2152	} else if (arg.constructor === String \|\| arg.constructor === Number) {
2153	strBuilder.push(arg);
2154	} else if (arg.constructor === Object) {
2155	break;
2156	}
2157	}
2158	if (i > 0) {
2159	logArgs.push(strBuilder.join(""));
2160	}
2161	for (; i < args2.length; i++) {
2162	const arg = args2[i];
2163	if (!(arg instanceof Symbol)) {
2164	logArgs.push(arg);
2165	}
2166	}
2167	return logArgs;
2168	};
2169	var lastLoggingTime = getUnixTime();
2170
2171	// node_modules/lib0/logging.js
2172	var _browserStyleMap = {
2173	[BOLD]: create5("font-weight", "bold"),
2174	[UNBOLD]: create5("font-weight", "normal"),
2175	[BLUE]: create5("color", "blue"),
2176	[GREEN]: create5("color", "green"),
2177	[GREY]: create5("color", "grey"),
2178	[RED]: create5("color", "red"),
2179	[PURPLE]: create5("color", "purple"),
2180	[ORANGE]: create5("color", "orange"),
2181	// not well supported in chrome when debugging node with inspector - TODO: deprecate
2182	[UNCOLOR]: create5("color", "black")
2183	};
2184	var computeBrowserLoggingArgs = (args2) => {
2185	if (args2.length === 1 && args2[0]?.constructor === Function) {
2186	args2 = /** @type {Array<string\|Symbol\|Object\|number>} */
2187	/** @type {[function]} */
2188	args2[0]();
2189	}
2190	const strBuilder = [];
2191	const styles = [];
2192	const currentStyle = create();
2193	let logArgs = [];
2194	let i = 0;
2195	for (; i < args2.length; i++) {
2196	const arg = args2[i];
2197	const style = _browserStyleMap[arg];
2198	if (style !== void 0) {
2199	currentStyle.set(style.left, style.right);
2200	} else {
2201	if (arg === void 0) {
2202	break;
2203	}
2204	if (arg.constructor === String \|\| arg.constructor === Number) {
2205	const style2 = mapToStyleString(currentStyle);
2206	if (i > 0 \|\| style2.length > 0) {
2207	strBuilder.push("%c" + arg);
2208	styles.push(style2);
2209	} else {
2210	strBuilder.push(arg);
2211	}
2212	} else {
2213	break;
2214	}
2215	}
2216	}
2217	if (i > 0) {
2218	logArgs = styles;
2219	logArgs.unshift(strBuilder.join(""));
2220	}
2221	for (; i < args2.length; i++) {
2222	const arg = args2[i];
2223	if (!(arg instanceof Symbol)) {
2224	logArgs.push(arg);
2225	}
2226	}
2227	return logArgs;
2228	};
2229	var computeLoggingArgs = supportsColor ? computeBrowserLoggingArgs : computeNoColorLoggingArgs;
2230	var print = (...args2) => {
2231	console.log(...computeLoggingArgs(args2));
2232	vconsoles.forEach((vc) => vc.print(args2));
2233	};
2234	var warn = (...args2) => {
2235	console.warn(...computeLoggingArgs(args2));
2236	args2.unshift(ORANGE);
2237	vconsoles.forEach((vc) => vc.print(args2));
2238	};
2239	var vconsoles = create2();
2240
2241	// node_modules/lib0/iterator.js
2242	var createIterator = (next) => ({
2243	/**
2244	* @return {IterableIterator<T>}
2245	*/
2246	[Symbol.iterator]() {
2247	return this;
2248	},
2249	// @ts-ignore
2250	next
2251	});
2252	var iteratorFilter = (iterator, filter) => createIterator(() => {
2253	let res;
2254	do {
2255	res = iterator.next();
2256	} while (!res.done && !filter(res.value));
2257	return res;
2258	});
2259	var iteratorMap = (iterator, fmap) => createIterator(() => {
2260	const { done, value } = iterator.next();
2261	return { done, value: done ? void 0 : fmap(value) };
2262	});
2263
2264	// node_modules/yjs/dist/yjs.mjs
2265	var AbstractConnector = class extends ObservableV2 {
2266	/**
2267	* @param {Doc} ydoc
2268	* @param {any} awareness
2269	*/
2270	constructor(ydoc, awareness) {
2271	super();
2272	this.doc = ydoc;
2273	this.awareness = awareness;
2274	}
2275	};
2276	var DeleteItem = class {
2277	/**
2278	* @param {number} clock
2279	* @param {number} len
2280	*/
2281	constructor(clock, len) {
2282	this.clock = clock;
2283	this.len = len;
2284	}
2285	};
2286	var DeleteSet = class {
2287	constructor() {
2288	this.clients = /* @__PURE__ */ new Map();
2289	}
2290	};
2291	var iterateDeletedStructs = (transaction, ds, f) => ds.clients.forEach((deletes, clientid) => {
2292	const structs = (
2293	/** @type {Array<GC\|Item>} */
2294	transaction.doc.store.clients.get(clientid)
2295	);
2296	if (structs != null) {
2297	const lastStruct = structs[structs.length - 1];
2298	const clockState = lastStruct.id.clock + lastStruct.length;
2299	for (let i = 0, del = deletes[i]; i < deletes.length && del.clock < clockState; del = deletes[++i]) {
2300	iterateStructs(transaction, structs, del.clock, del.len, f);
2301	}
2302	}
2303	});
2304	var findIndexDS = (dis, clock) => {
2305	let left = 0;
2306	let right = dis.length - 1;
2307	while (left <= right) {
2308	const midindex = floor((left + right) / 2);
2309	const mid = dis[midindex];
2310	const midclock = mid.clock;
2311	if (midclock <= clock) {
2312	if (clock < midclock + mid.len) {
2313	return midindex;
2314	}
2315	left = midindex + 1;
2316	} else {
2317	right = midindex - 1;
2318	}
2319	}
2320	return null;
2321	};
2322	var isDeleted = (ds, id2) => {
2323	const dis = ds.clients.get(id2.client);
2324	return dis !== void 0 && findIndexDS(dis, id2.clock) !== null;
2325	};
2326	var sortAndMergeDeleteSet = (ds) => {
2327	ds.clients.forEach((dels) => {
2328	dels.sort((a, b) => a.clock - b.clock);
2329	let i, j;
2330	for (i = 1, j = 1; i < dels.length; i++) {
2331	const left = dels[j - 1];
2332	const right = dels[i];
2333	if (left.clock + left.len >= right.clock) {
2334	left.len = max(left.len, right.clock + right.len - left.clock);
2335	} else {
2336	if (j < i) {
2337	dels[j] = right;
2338	}
2339	j++;
2340	}
2341	}
2342	dels.length = j;
2343	});
2344	};
2345	var mergeDeleteSets = (dss) => {
2346	const merged = new DeleteSet();
2347	for (let dssI = 0; dssI < dss.length; dssI++) {
2348	dss[dssI].clients.forEach((delsLeft, client) => {
2349	if (!merged.clients.has(client)) {
2350	const dels = delsLeft.slice();
2351	for (let i = dssI + 1; i < dss.length; i++) {
2352	appendTo(dels, dss[i].clients.get(client) \|\| []);
2353	}
2354	merged.clients.set(client, dels);
2355	}
2356	});
2357	}
2358	sortAndMergeDeleteSet(merged);
2359	return merged;
2360	};
2361	var addToDeleteSet = (ds, client, clock, length2) => {
2362	setIfUndefined(ds.clients, client, () => (
2363	/** @type {Array<DeleteItem>} */
2364	[]
2365	)).push(new DeleteItem(clock, length2));
2366	};
2367	var createDeleteSet = () => new DeleteSet();
2368	var createDeleteSetFromStructStore = (ss) => {
2369	const ds = createDeleteSet();
2370	ss.clients.forEach((structs, client) => {
2371	const dsitems = [];
2372	for (let i = 0; i < structs.length; i++) {
2373	const struct = structs[i];
2374	if (struct.deleted) {
2375	const clock = struct.id.clock;
2376	let len = struct.length;
2377	if (i + 1 < structs.length) {
2378	for (let next = structs[i + 1]; i + 1 < structs.length && next.deleted; next = structs[++i + 1]) {
2379	len += next.length;
2380	}
2381	}
2382	dsitems.push(new DeleteItem(clock, len));
2383	}
2384	}
2385	if (dsitems.length > 0) {
2386	ds.clients.set(client, dsitems);
2387	}
2388	});
2389	return ds;
2390	};
2391	var writeDeleteSet = (encoder, ds) => {
2392	writeVarUint(encoder.restEncoder, ds.clients.size);
2393	from(ds.clients.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, dsitems]) => {
2394	encoder.resetDsCurVal();
2395	writeVarUint(encoder.restEncoder, client);
2396	const len = dsitems.length;
2397	writeVarUint(encoder.restEncoder, len);
2398	for (let i = 0; i < len; i++) {
2399	const item = dsitems[i];
2400	encoder.writeDsClock(item.clock);
2401	encoder.writeDsLen(item.len);
2402	}
2403	});
2404	};
2405	var readDeleteSet = (decoder) => {
2406	const ds = new DeleteSet();
2407	const numClients = readVarUint(decoder.restDecoder);
2408	for (let i = 0; i < numClients; i++) {
2409	decoder.resetDsCurVal();
2410	const client = readVarUint(decoder.restDecoder);
2411	const numberOfDeletes = readVarUint(decoder.restDecoder);
2412	if (numberOfDeletes > 0) {
2413	const dsField = setIfUndefined(ds.clients, client, () => (
2414	/** @type {Array<DeleteItem>} */
2415	[]
2416	));
2417	for (let i2 = 0; i2 < numberOfDeletes; i2++) {
2418	dsField.push(new DeleteItem(decoder.readDsClock(), decoder.readDsLen()));
2419	}
2420	}
2421	}
2422	return ds;
2423	};
2424	var readAndApplyDeleteSet = (decoder, transaction, store) => {
2425	const unappliedDS = new DeleteSet();
2426	const numClients = readVarUint(decoder.restDecoder);
2427	for (let i = 0; i < numClients; i++) {
2428	decoder.resetDsCurVal();
2429	const client = readVarUint(decoder.restDecoder);
2430	const numberOfDeletes = readVarUint(decoder.restDecoder);
2431	const structs = store.clients.get(client) \|\| [];
2432	const state = getState(store, client);
2433	for (let i2 = 0; i2 < numberOfDeletes; i2++) {
2434	const clock = decoder.readDsClock();
2435	const clockEnd = clock + decoder.readDsLen();
2436	if (clock < state) {
2437	if (state < clockEnd) {
2438	addToDeleteSet(unappliedDS, client, state, clockEnd - state);
2439	}
2440	let index = findIndexSS(structs, clock);
2441	let struct = structs[index];
2442	if (!struct.deleted && struct.id.clock < clock) {
2443	structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));
2444	index++;
2445	}
2446	while (index < structs.length) {
2447	struct = structs[index++];
2448	if (struct.id.clock < clockEnd) {
2449	if (!struct.deleted) {
2450	if (clockEnd < struct.id.clock + struct.length) {
2451	structs.splice(index, 0, splitItem(transaction, struct, clockEnd - struct.id.clock));
2452	}
2453	struct.delete(transaction);
2454	}
2455	} else {
2456	break;
2457	}
2458	}
2459	} else {
2460	addToDeleteSet(unappliedDS, client, clock, clockEnd - clock);
2461	}
2462	}
2463	}
2464	if (unappliedDS.clients.size > 0) {
2465	const ds = new UpdateEncoderV2();
2466	writeVarUint(ds.restEncoder, 0);
2467	writeDeleteSet(ds, unappliedDS);
2468	return ds.toUint8Array();
2469	}
2470	return null;
2471	};
2472	var equalDeleteSets = (ds1, ds2) => {
2473	if (ds1.clients.size !== ds2.clients.size) return false;
2474	for (const [client, deleteItems1] of ds1.clients.entries()) {
2475	const deleteItems2 = (
2476	/** @type {Array<import('../internals.js').DeleteItem>} */
2477	ds2.clients.get(client)
2478	);
2479	if (deleteItems2 === void 0 \|\| deleteItems1.length !== deleteItems2.length) return false;
2480	for (let i = 0; i < deleteItems1.length; i++) {
2481	const di1 = deleteItems1[i];
2482	const di2 = deleteItems2[i];
2483	if (di1.clock !== di2.clock \|\| di1.len !== di2.len) {
2484	return false;
2485	}
2486	}
2487	}
2488	return true;
2489	};
2490	var generateNewClientId = uint32;
2491	var Doc = class _Doc extends ObservableV2 {
2492	/**
2493	* @param {DocOpts} opts configuration
2494	*/
2495	constructor({ guid = uuidv4(), collectionid = null, gc = true, gcFilter = () => true, meta = null, autoLoad = false, shouldLoad = true } = {}) {
2496	super();
2497	this.gc = gc;
2498	this.gcFilter = gcFilter;
2499	this.clientID = generateNewClientId();
2500	this.guid = guid;
2501	this.collectionid = collectionid;
2502	this.share = /* @__PURE__ */ new Map();
2503	this.store = new StructStore();
2504	this._transaction = null;
2505	this._transactionCleanups = [];
2506	this.subdocs = /* @__PURE__ */ new Set();
2507	this._item = null;
2508	this.shouldLoad = shouldLoad;
2509	this.autoLoad = autoLoad;
2510	this.meta = meta;
2511	this.isLoaded = false;
2512	this.isSynced = false;
2513	this.isDestroyed = false;
2514	this.whenLoaded = create4((resolve) => {
2515	this.on("load", () => {
2516	this.isLoaded = true;
2517	resolve(this);
2518	});
2519	});
2520	const provideSyncedPromise = () => create4((resolve) => {
2521	const eventHandler = (isSynced) => {
2522	if (isSynced === void 0 \|\| isSynced === true) {
2523	this.off("sync", eventHandler);
2524	resolve();
2525	}
2526	};
2527	this.on("sync", eventHandler);
2528	});
2529	this.on("sync", (isSynced) => {
2530	if (isSynced === false && this.isSynced) {
2531	this.whenSynced = provideSyncedPromise();
2532	}
2533	this.isSynced = isSynced === void 0 \|\| isSynced === true;
2534	if (this.isSynced && !this.isLoaded) {
2535	this.emit("load", [this]);
2536	}
2537	});
2538	this.whenSynced = provideSyncedPromise();
2539	}
2540	/**
2541	* Notify the parent document that you request to load data into this subdocument (if it is a subdocument).
2542	*
2543	* `load()` might be used in the future to request any provider to load the most current data.
2544	*
2545	* It is safe to call `load()` multiple times.
2546	*/
2547	load() {
2548	const item = this._item;
2549	if (item !== null && !this.shouldLoad) {
2550	transact(
2551	/** @type {any} */
2552	item.parent.doc,
2553	(transaction) => {
2554	transaction.subdocsLoaded.add(this);
2555	},
2556	null,
2557	true
2558	);
2559	}
2560	this.shouldLoad = true;
2561	}
2562	getSubdocs() {
2563	return this.subdocs;
2564	}
2565	getSubdocGuids() {
2566	return new Set(from(this.subdocs).map((doc2) => doc2.guid));
2567	}
2568	/**
2569	* Changes that happen inside of a transaction are bundled. This means that
2570	* the observer fires _after_ the transaction is finished and that all changes
2571	* that happened inside of the transaction are sent as one message to the
2572	* other peers.
2573	*
2574	* @template T
2575	* @param {function(Transaction):T} f The function that should be executed as a transaction
2576	* @param {any} [origin] Origin of who started the transaction. Will be stored on transaction.origin
2577	* @return T
2578	*
2579	* @public
2580	*/
2581	transact(f, origin2 = null) {
2582	return transact(this, f, origin2);
2583	}
2584	/**
2585	* Define a shared data type.
2586	*
2587	* Multiple calls of `ydoc.get(name, TypeConstructor)` yield the same result
2588	* and do not overwrite each other. I.e.
2589	* `ydoc.get(name, Y.Array) === ydoc.get(name, Y.Array)`
2590	*
2591	* After this method is called, the type is also available on `ydoc.share.get(name)`.
2592	*
2593	* Best Practices:
2594	* Define all types right after the Y.Doc instance is created and store them in a separate object.
2595	* Also use the typed methods `getText(name)`, `getArray(name)`, ..
2596	*
2597	* @template {typeof AbstractType<any>} Type
2598	* @example
2599	* const ydoc = new Y.Doc(..)
2600	* const appState = {
2601	* document: ydoc.getText('document')
2602	* comments: ydoc.getArray('comments')
2603	* }
2604	*
2605	* @param {string} name
2606	* @param {Type} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...
2607	* @return {InstanceType<Type>} The created type. Constructed with TypeConstructor
2608	*
2609	* @public
2610	*/
2611	get(name, TypeConstructor = (
2612	/** @type {any} */
2613	AbstractType
2614	)) {
2615	const type = setIfUndefined(this.share, name, () => {
2616	const t = new TypeConstructor();
2617	t._integrate(this, null);
2618	return t;
2619	});
2620	const Constr = type.constructor;
2621	if (TypeConstructor !== AbstractType && Constr !== TypeConstructor) {
2622	if (Constr === AbstractType) {
2623	const t = new TypeConstructor();
2624	t._map = type._map;
2625	type._map.forEach(
2626	/** @param {Item?} n */
2627	(n) => {
2628	for (; n !== null; n = n.left) {
2629	n.parent = t;
2630	}
2631	}
2632	);
2633	t._start = type._start;
2634	for (let n = t._start; n !== null; n = n.right) {
2635	n.parent = t;
2636	}
2637	t._length = type._length;
2638	this.share.set(name, t);
2639	t._integrate(this, null);
2640	return (
2641	/** @type {InstanceType<Type>} */
2642	t
2643	);
2644	} else {
2645	throw new Error(`Type with the name ${name} has already been defined with a different constructor`);
2646	}
2647	}
2648	return (
2649	/** @type {InstanceType<Type>} */
2650	type
2651	);
2652	}
2653	/**
2654	* @template T
2655	* @param {string} [name]
2656	* @return {YArray<T>}
2657	*
2658	* @public
2659	*/
2660	getArray(name = "") {
2661	return (
2662	/** @type {YArray<T>} */
2663	this.get(name, YArray)
2664	);
2665	}
2666	/**
2667	* @param {string} [name]
2668	* @return {YText}
2669	*
2670	* @public
2671	*/
2672	getText(name = "") {
2673	return this.get(name, YText);
2674	}
2675	/**
2676	* @template T
2677	* @param {string} [name]
2678	* @return {YMap<T>}
2679	*
2680	* @public
2681	*/
2682	getMap(name = "") {
2683	return (
2684	/** @type {YMap<T>} */
2685	this.get(name, YMap)
2686	);
2687	}
2688	/**
2689	* @param {string} [name]
2690	* @return {YXmlElement}
2691	*
2692	* @public
2693	*/
2694	getXmlElement(name = "") {
2695	return (
2696	/** @type {YXmlElement<{[key:string]:string}>} */
2697	this.get(name, YXmlElement)
2698	);
2699	}
2700	/**
2701	* @param {string} [name]
2702	* @return {YXmlFragment}
2703	*
2704	* @public
2705	*/
2706	getXmlFragment(name = "") {
2707	return this.get(name, YXmlFragment);
2708	}
2709	/**
2710	* Converts the entire document into a js object, recursively traversing each yjs type
2711	* Doesn't log types that have not been defined (using ydoc.getType(..)).
2712	*
2713	* @deprecated Do not use this method and rather call toJSON directly on the shared types.
2714	*
2715	* @return {Object<string, any>}
2716	*/
2717	toJSON() {
2718	const doc2 = {};
2719	this.share.forEach((value, key) => {
2720	doc2[key] = value.toJSON();
2721	});
2722	return doc2;
2723	}
2724	/**
2725	* Emit `destroy` event and unregister all event handlers.
2726	*/
2727	destroy() {
2728	this.isDestroyed = true;
2729	from(this.subdocs).forEach((subdoc) => subdoc.destroy());
2730	const item = this._item;
2731	if (item !== null) {
2732	this._item = null;
2733	const content = (
2734	/** @type {ContentDoc} */
2735	item.content
2736	);
2737	content.doc = new _Doc({ guid: this.guid, ...content.opts, shouldLoad: false });
2738	content.doc._item = item;
2739	transact(
2740	/** @type {any} */
2741	item.parent.doc,
2742	(transaction) => {
2743	const doc2 = content.doc;
2744	if (!item.deleted) {
2745	transaction.subdocsAdded.add(doc2);
2746	}
2747	transaction.subdocsRemoved.add(this);
2748	},
2749	null,
2750	true
2751	);
2752	}
2753	this.emit("destroyed", [true]);
2754	this.emit("destroy", [this]);
2755	super.destroy();
2756	}
2757	};
2758	var DSDecoderV1 = class {
2759	/**
2760	* @param {decoding.Decoder} decoder
2761	*/
2762	constructor(decoder) {
2763	this.restDecoder = decoder;
2764	}
2765	resetDsCurVal() {
2766	}
2767	/**
2768	* @return {number}
2769	*/
2770	readDsClock() {
2771	return readVarUint(this.restDecoder);
2772	}
2773	/**
2774	* @return {number}
2775	*/
2776	readDsLen() {
2777	return readVarUint(this.restDecoder);
2778	}
2779	};
2780	var UpdateDecoderV1 = class extends DSDecoderV1 {
2781	/**
2782	* @return {ID}
2783	*/
2784	readLeftID() {
2785	return createID(readVarUint(this.restDecoder), readVarUint(this.restDecoder));
2786	}
2787	/**
2788	* @return {ID}
2789	*/
2790	readRightID() {
2791	return createID(readVarUint(this.restDecoder), readVarUint(this.restDecoder));
2792	}
2793	/**
2794	* Read the next client id.
2795	* Use this in favor of readID whenever possible to reduce the number of objects created.
2796	*/
2797	readClient() {
2798	return readVarUint(this.restDecoder);
2799	}
2800	/**
2801	* @return {number} info An unsigned 8-bit integer
2802	*/
2803	readInfo() {
2804	return readUint8(this.restDecoder);
2805	}
2806	/**
2807	* @return {string}
2808	*/
2809	readString() {
2810	return readVarString(this.restDecoder);
2811	}
2812	/**
2813	* @return {boolean} isKey
2814	*/
2815	readParentInfo() {
2816	return readVarUint(this.restDecoder) === 1;
2817	}
2818	/**
2819	* @return {number} info An unsigned 8-bit integer
2820	*/
2821	readTypeRef() {
2822	return readVarUint(this.restDecoder);
2823	}
2824	/**
2825	* Write len of a struct - well suited for Opt RLE encoder.
2826	*
2827	* @return {number} len
2828	*/
2829	readLen() {
2830	return readVarUint(this.restDecoder);
2831	}
2832	/**
2833	* @return {any}
2834	*/
2835	readAny() {
2836	return readAny(this.restDecoder);
2837	}
2838	/**
2839	* @return {Uint8Array}
2840	*/
2841	readBuf() {
2842	return copyUint8Array(readVarUint8Array(this.restDecoder));
2843	}
2844	/**
2845	* Legacy implementation uses JSON parse. We use any-decoding in v2.
2846	*
2847	* @return {any}
2848	*/
2849	readJSON() {
2850	return JSON.parse(readVarString(this.restDecoder));
2851	}
2852	/**
2853	* @return {string}
2854	*/
2855	readKey() {
2856	return readVarString(this.restDecoder);
2857	}
2858	};
2859	var DSDecoderV2 = class {
2860	/**
2861	* @param {decoding.Decoder} decoder
2862	*/
2863	constructor(decoder) {
2864	this.dsCurrVal = 0;
2865	this.restDecoder = decoder;
2866	}
2867	resetDsCurVal() {
2868	this.dsCurrVal = 0;
2869	}
2870	/**
2871	* @return {number}
2872	*/
2873	readDsClock() {
2874	this.dsCurrVal += readVarUint(this.restDecoder);
2875	return this.dsCurrVal;
2876	}
2877	/**
2878	* @return {number}
2879	*/
2880	readDsLen() {
2881	const diff = readVarUint(this.restDecoder) + 1;
2882	this.dsCurrVal += diff;
2883	return diff;
2884	}
2885	};
2886	var UpdateDecoderV2 = class extends DSDecoderV2 {
2887	/**
2888	* @param {decoding.Decoder} decoder
2889	*/
2890	constructor(decoder) {
2891	super(decoder);
2892	this.keys = [];
2893	readVarUint(decoder);
2894	this.keyClockDecoder = new IntDiffOptRleDecoder(readVarUint8Array(decoder));
2895	this.clientDecoder = new UintOptRleDecoder(readVarUint8Array(decoder));
2896	this.leftClockDecoder = new IntDiffOptRleDecoder(readVarUint8Array(decoder));
2897	this.rightClockDecoder = new IntDiffOptRleDecoder(readVarUint8Array(decoder));
2898	this.infoDecoder = new RleDecoder(readVarUint8Array(decoder), readUint8);
2899	this.stringDecoder = new StringDecoder(readVarUint8Array(decoder));
2900	this.parentInfoDecoder = new RleDecoder(readVarUint8Array(decoder), readUint8);
2901	this.typeRefDecoder = new UintOptRleDecoder(readVarUint8Array(decoder));
2902	this.lenDecoder = new UintOptRleDecoder(readVarUint8Array(decoder));
2903	}
2904	/**
2905	* @return {ID}
2906	*/
2907	readLeftID() {
2908	return new ID(this.clientDecoder.read(), this.leftClockDecoder.read());
2909	}
2910	/**
2911	* @return {ID}
2912	*/
2913	readRightID() {
2914	return new ID(this.clientDecoder.read(), this.rightClockDecoder.read());
2915	}
2916	/**
2917	* Read the next client id.
2918	* Use this in favor of readID whenever possible to reduce the number of objects created.
2919	*/
2920	readClient() {
2921	return this.clientDecoder.read();
2922	}
2923	/**
2924	* @return {number} info An unsigned 8-bit integer
2925	*/
2926	readInfo() {
2927	return (
2928	/** @type {number} */
2929	this.infoDecoder.read()
2930	);
2931	}
2932	/**
2933	* @return {string}
2934	*/
2935	readString() {
2936	return this.stringDecoder.read();
2937	}
2938	/**
2939	* @return {boolean}
2940	*/
2941	readParentInfo() {
2942	return this.parentInfoDecoder.read() === 1;
2943	}
2944	/**
2945	* @return {number} An unsigned 8-bit integer
2946	*/
2947	readTypeRef() {
2948	return this.typeRefDecoder.read();
2949	}
2950	/**
2951	* Write len of a struct - well suited for Opt RLE encoder.
2952	*
2953	* @return {number}
2954	*/
2955	readLen() {
2956	return this.lenDecoder.read();
2957	}
2958	/**
2959	* @return {any}
2960	*/
2961	readAny() {
2962	return readAny(this.restDecoder);
2963	}
2964	/**
2965	* @return {Uint8Array}
2966	*/
2967	readBuf() {
2968	return readVarUint8Array(this.restDecoder);
2969	}
2970	/**
2971	* This is mainly here for legacy purposes.
2972	*
2973	* Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
2974	*
2975	* @return {any}
2976	*/
2977	readJSON() {
2978	return readAny(this.restDecoder);
2979	}
2980	/**
2981	* @return {string}
2982	*/
2983	readKey() {
2984	const keyClock = this.keyClockDecoder.read();
2985	if (keyClock < this.keys.length) {
2986	return this.keys[keyClock];
2987	} else {
2988	const key = this.stringDecoder.read();
2989	this.keys.push(key);
2990	return key;
2991	}
2992	}
2993	};
2994	var DSEncoderV1 = class {
2995	constructor() {
2996	this.restEncoder = createEncoder();
2997	}
2998	toUint8Array() {
2999	return toUint8Array(this.restEncoder);
3000	}
3001	resetDsCurVal() {
3002	}
3003	/**
3004	* @param {number} clock
3005	*/
3006	writeDsClock(clock) {
3007	writeVarUint(this.restEncoder, clock);
3008	}
3009	/**
3010	* @param {number} len
3011	*/
3012	writeDsLen(len) {
3013	writeVarUint(this.restEncoder, len);
3014	}
3015	};
3016	var UpdateEncoderV1 = class extends DSEncoderV1 {
3017	/**
3018	* @param {ID} id
3019	*/
3020	writeLeftID(id2) {
3021	writeVarUint(this.restEncoder, id2.client);
3022	writeVarUint(this.restEncoder, id2.clock);
3023	}
3024	/**
3025	* @param {ID} id
3026	*/
3027	writeRightID(id2) {
3028	writeVarUint(this.restEncoder, id2.client);
3029	writeVarUint(this.restEncoder, id2.clock);
3030	}
3031	/**
3032	* Use writeClient and writeClock instead of writeID if possible.
3033	* @param {number} client
3034	*/
3035	writeClient(client) {
3036	writeVarUint(this.restEncoder, client);
3037	}
3038	/**
3039	* @param {number} info An unsigned 8-bit integer
3040	*/
3041	writeInfo(info) {
3042	writeUint8(this.restEncoder, info);
3043	}
3044	/**
3045	* @param {string} s
3046	*/
3047	writeString(s) {
3048	writeVarString(this.restEncoder, s);
3049	}
3050	/**
3051	* @param {boolean} isYKey
3052	*/
3053	writeParentInfo(isYKey) {
3054	writeVarUint(this.restEncoder, isYKey ? 1 : 0);
3055	}
3056	/**
3057	* @param {number} info An unsigned 8-bit integer
3058	*/
3059	writeTypeRef(info) {
3060	writeVarUint(this.restEncoder, info);
3061	}
3062	/**
3063	* Write len of a struct - well suited for Opt RLE encoder.
3064	*
3065	* @param {number} len
3066	*/
3067	writeLen(len) {
3068	writeVarUint(this.restEncoder, len);
3069	}
3070	/**
3071	* @param {any} any
3072	*/
3073	writeAny(any2) {
3074	writeAny(this.restEncoder, any2);
3075	}
3076	/**
3077	* @param {Uint8Array} buf
3078	*/
3079	writeBuf(buf) {
3080	writeVarUint8Array(this.restEncoder, buf);
3081	}
3082	/**
3083	* @param {any} embed
3084	*/
3085	writeJSON(embed) {
3086	writeVarString(this.restEncoder, JSON.stringify(embed));
3087	}
3088	/**
3089	* @param {string} key
3090	*/
3091	writeKey(key) {
3092	writeVarString(this.restEncoder, key);
3093	}
3094	};
3095	var DSEncoderV2 = class {
3096	constructor() {
3097	this.restEncoder = createEncoder();
3098	this.dsCurrVal = 0;
3099	}
3100	toUint8Array() {
3101	return toUint8Array(this.restEncoder);
3102	}
3103	resetDsCurVal() {
3104	this.dsCurrVal = 0;
3105	}
3106	/**
3107	* @param {number} clock
3108	*/
3109	writeDsClock(clock) {
3110	const diff = clock - this.dsCurrVal;
3111	this.dsCurrVal = clock;
3112	writeVarUint(this.restEncoder, diff);
3113	}
3114	/**
3115	* @param {number} len
3116	*/
3117	writeDsLen(len) {
3118	if (len === 0) {
3119	unexpectedCase();
3120	}
3121	writeVarUint(this.restEncoder, len - 1);
3122	this.dsCurrVal += len;
3123	}
3124	};
3125	var UpdateEncoderV2 = class extends DSEncoderV2 {
3126	constructor() {
3127	super();
3128	this.keyMap = /* @__PURE__ */ new Map();
3129	this.keyClock = 0;
3130	this.keyClockEncoder = new IntDiffOptRleEncoder();
3131	this.clientEncoder = new UintOptRleEncoder();
3132	this.leftClockEncoder = new IntDiffOptRleEncoder();
3133	this.rightClockEncoder = new IntDiffOptRleEncoder();
3134	this.infoEncoder = new RleEncoder(writeUint8);
3135	this.stringEncoder = new StringEncoder();
3136	this.parentInfoEncoder = new RleEncoder(writeUint8);
3137	this.typeRefEncoder = new UintOptRleEncoder();
3138	this.lenEncoder = new UintOptRleEncoder();
3139	}
3140	toUint8Array() {
3141	const encoder = createEncoder();
3142	writeVarUint(encoder, 0);
3143	writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array());
3144	writeVarUint8Array(encoder, this.clientEncoder.toUint8Array());
3145	writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array());
3146	writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array());
3147	writeVarUint8Array(encoder, toUint8Array(this.infoEncoder));
3148	writeVarUint8Array(encoder, this.stringEncoder.toUint8Array());
3149	writeVarUint8Array(encoder, toUint8Array(this.parentInfoEncoder));
3150	writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array());
3151	writeVarUint8Array(encoder, this.lenEncoder.toUint8Array());
3152	writeUint8Array(encoder, toUint8Array(this.restEncoder));
3153	return toUint8Array(encoder);
3154	}
3155	/**
3156	* @param {ID} id
3157	*/
3158	writeLeftID(id2) {
3159	this.clientEncoder.write(id2.client);
3160	this.leftClockEncoder.write(id2.clock);
3161	}
3162	/**
3163	* @param {ID} id
3164	*/
3165	writeRightID(id2) {
3166	this.clientEncoder.write(id2.client);
3167	this.rightClockEncoder.write(id2.clock);
3168	}
3169	/**
3170	* @param {number} client
3171	*/
3172	writeClient(client) {
3173	this.clientEncoder.write(client);
3174	}
3175	/**
3176	* @param {number} info An unsigned 8-bit integer
3177	*/
3178	writeInfo(info) {
3179	this.infoEncoder.write(info);
3180	}
3181	/**
3182	* @param {string} s
3183	*/
3184	writeString(s) {
3185	this.stringEncoder.write(s);
3186	}
3187	/**
3188	* @param {boolean} isYKey
3189	*/
3190	writeParentInfo(isYKey) {
3191	this.parentInfoEncoder.write(isYKey ? 1 : 0);
3192	}
3193	/**
3194	* @param {number} info An unsigned 8-bit integer
3195	*/
3196	writeTypeRef(info) {
3197	this.typeRefEncoder.write(info);
3198	}
3199	/**
3200	* Write len of a struct - well suited for Opt RLE encoder.
3201	*
3202	* @param {number} len
3203	*/
3204	writeLen(len) {
3205	this.lenEncoder.write(len);
3206	}
3207	/**
3208	* @param {any} any
3209	*/
3210	writeAny(any2) {
3211	writeAny(this.restEncoder, any2);
3212	}
3213	/**
3214	* @param {Uint8Array} buf
3215	*/
3216	writeBuf(buf) {
3217	writeVarUint8Array(this.restEncoder, buf);
3218	}
3219	/**
3220	* This is mainly here for legacy purposes.
3221	*
3222	* Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
3223	*
3224	* @param {any} embed
3225	*/
3226	writeJSON(embed) {
3227	writeAny(this.restEncoder, embed);
3228	}
3229	/**
3230	* Property keys are often reused. For example, in y-prosemirror the key `bold` might
3231	* occur very often. For a 3d application, the key `position` might occur very often.
3232	*
3233	* We cache these keys in a Map and refer to them via a unique number.
3234	*
3235	* @param {string} key
3236	*/
3237	writeKey(key) {
3238	const clock = this.keyMap.get(key);
3239	if (clock === void 0) {
3240	this.keyClockEncoder.write(this.keyClock++);
3241	this.stringEncoder.write(key);
3242	} else {
3243	this.keyClockEncoder.write(clock);
3244	}
3245	}
3246	};
3247	var writeStructs = (encoder, structs, client, clock) => {
3248	clock = max(clock, structs[0].id.clock);
3249	const startNewStructs = findIndexSS(structs, clock);
3250	writeVarUint(encoder.restEncoder, structs.length - startNewStructs);
3251	encoder.writeClient(client);
3252	writeVarUint(encoder.restEncoder, clock);
3253	const firstStruct = structs[startNewStructs];
3254	firstStruct.write(encoder, clock - firstStruct.id.clock);
3255	for (let i = startNewStructs + 1; i < structs.length; i++) {
3256	structs[i].write(encoder, 0);
3257	}
3258	};
3259	var writeClientsStructs = (encoder, store, _sm) => {
3260	const sm = /* @__PURE__ */ new Map();
3261	_sm.forEach((clock, client) => {
3262	if (getState(store, client) > clock) {
3263	sm.set(client, clock);
3264	}
3265	});
3266	getStateVector(store).forEach((_clock, client) => {
3267	if (!_sm.has(client)) {
3268	sm.set(client, 0);
3269	}
3270	});
3271	writeVarUint(encoder.restEncoder, sm.size);
3272	from(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
3273	writeStructs(
3274	encoder,
3275	/** @type {Array<GC\|Item>} */
3276	store.clients.get(client),
3277	client,
3278	clock
3279	);
3280	});
3281	};
3282	var readClientsStructRefs = (decoder, doc2) => {
3283	const clientRefs = create();
3284	const numOfStateUpdates = readVarUint(decoder.restDecoder);
3285	for (let i = 0; i < numOfStateUpdates; i++) {
3286	const numberOfStructs = readVarUint(decoder.restDecoder);
3287	const refs = new Array(numberOfStructs);
3288	const client = decoder.readClient();
3289	let clock = readVarUint(decoder.restDecoder);
3290	clientRefs.set(client, { i: 0, refs });
3291	for (let i2 = 0; i2 < numberOfStructs; i2++) {
3292	const info = decoder.readInfo();
3293	switch (BITS5 & info) {
3294	case 0: {
3295	const len = decoder.readLen();
3296	refs[i2] = new GC(createID(client, clock), len);
3297	clock += len;
3298	break;
3299	}
3300	case 10: {
3301	const len = readVarUint(decoder.restDecoder);
3302	refs[i2] = new Skip(createID(client, clock), len);
3303	clock += len;
3304	break;
3305	}
3306	default: {
3307	const cantCopyParentInfo = (info & (BIT7 \| BIT8)) === 0;
3308	const struct = new Item(
3309	createID(client, clock),
3310	null,
3311	// left
3312	(info & BIT8) === BIT8 ? decoder.readLeftID() : null,
3313	// origin
3314	null,
3315	// right
3316	(info & BIT7) === BIT7 ? decoder.readRightID() : null,
3317	// right origin
3318	cantCopyParentInfo ? decoder.readParentInfo() ? doc2.get(decoder.readString()) : decoder.readLeftID() : null,
3319	// parent
3320	cantCopyParentInfo && (info & BIT6) === BIT6 ? decoder.readString() : null,
3321	// parentSub
3322	readItemContent(decoder, info)
3323	// item content
3324	);
3325	refs[i2] = struct;
3326	clock += struct.length;
3327	}
3328	}
3329	}
3330	}
3331	return clientRefs;
3332	};
3333	var integrateStructs = (transaction, store, clientsStructRefs) => {
3334	const stack = [];
3335	let clientsStructRefsIds = from(clientsStructRefs.keys()).sort((a, b) => a - b);
3336	if (clientsStructRefsIds.length === 0) {
3337	return null;
3338	}
3339	const getNextStructTarget = () => {
3340	if (clientsStructRefsIds.length === 0) {
3341	return null;
3342	}
3343	let nextStructsTarget = (
3344	/** @type {{i:number,refs:Array<GC\|Item>}} */
3345	clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1])
3346	);
3347	while (nextStructsTarget.refs.length === nextStructsTarget.i) {
3348	clientsStructRefsIds.pop();
3349	if (clientsStructRefsIds.length > 0) {
3350	nextStructsTarget = /** @type {{i:number,refs:Array<GC\|Item>}} */
3351	clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1]);
3352	} else {
3353	return null;
3354	}
3355	}
3356	return nextStructsTarget;
3357	};
3358	let curStructsTarget = getNextStructTarget();
3359	if (curStructsTarget === null) {
3360	return null;
3361	}
3362	const restStructs = new StructStore();
3363	const missingSV = /* @__PURE__ */ new Map();
3364	const updateMissingSv = (client, clock) => {
3365	const mclock = missingSV.get(client);
3366	if (mclock == null \|\| mclock > clock) {
3367	missingSV.set(client, clock);
3368	}
3369	};
3370	let stackHead = (
3371	/** @type {any} */
3372	curStructsTarget.refs[
3373	/** @type {any} */
3374	curStructsTarget.i++
3375	]
3376	);
3377	const state = /* @__PURE__ */ new Map();
3378	const addStackToRestSS = () => {
3379	for (const item of stack) {
3380	const client = item.id.client;
3381	const inapplicableItems = clientsStructRefs.get(client);
3382	if (inapplicableItems) {
3383	inapplicableItems.i--;
3384	restStructs.clients.set(client, inapplicableItems.refs.slice(inapplicableItems.i));
3385	clientsStructRefs.delete(client);
3386	inapplicableItems.i = 0;
3387	inapplicableItems.refs = [];
3388	} else {
3389	restStructs.clients.set(client, [item]);
3390	}
3391	clientsStructRefsIds = clientsStructRefsIds.filter((c) => c !== client);
3392	}
3393	stack.length = 0;
3394	};
3395	while (true) {
3396	if (stackHead.constructor !== Skip) {
3397	const localClock = setIfUndefined(state, stackHead.id.client, () => getState(store, stackHead.id.client));
3398	const offset = localClock - stackHead.id.clock;
3399	if (offset < 0) {
3400	stack.push(stackHead);
3401	updateMissingSv(stackHead.id.client, stackHead.id.clock - 1);
3402	addStackToRestSS();
3403	} else {
3404	const missing = stackHead.getMissing(transaction, store);
3405	if (missing !== null) {
3406	stack.push(stackHead);
3407	const structRefs = clientsStructRefs.get(
3408	/** @type {number} */
3409	missing
3410	) \|\| { refs: [], i: 0 };
3411	if (structRefs.refs.length === structRefs.i) {
3412	updateMissingSv(
3413	/** @type {number} */
3414	missing,
3415	getState(store, missing)
3416	);
3417	addStackToRestSS();
3418	} else {
3419	stackHead = structRefs.refs[structRefs.i++];
3420	continue;
3421	}
3422	} else if (offset === 0 \|\| offset < stackHead.length) {
3423	stackHead.integrate(transaction, offset);
3424	state.set(stackHead.id.client, stackHead.id.clock + stackHead.length);
3425	}
3426	}
3427	}
3428	if (stack.length > 0) {
3429	stackHead = /** @type {GC\|Item} */
3430	stack.pop();
3431	} else if (curStructsTarget !== null && curStructsTarget.i < curStructsTarget.refs.length) {
3432	stackHead = /** @type {GC\|Item} */
3433	curStructsTarget.refs[curStructsTarget.i++];
3434	} else {
3435	curStructsTarget = getNextStructTarget();
3436	if (curStructsTarget === null) {
3437	break;
3438	} else {
3439	stackHead = /** @type {GC\|Item} */
3440	curStructsTarget.refs[curStructsTarget.i++];
3441	}
3442	}
3443	}
3444	if (restStructs.clients.size > 0) {
3445	const encoder = new UpdateEncoderV2();
3446	writeClientsStructs(encoder, restStructs, /* @__PURE__ */ new Map());
3447	writeVarUint(encoder.restEncoder, 0);
3448	return { missing: missingSV, update: encoder.toUint8Array() };
3449	}
3450	return null;
3451	};
3452	var writeStructsFromTransaction = (encoder, transaction) => writeClientsStructs(encoder, transaction.doc.store, transaction.beforeState);
3453	var readUpdateV2 = (decoder, ydoc, transactionOrigin, structDecoder = new UpdateDecoderV2(decoder)) => transact(ydoc, (transaction) => {
3454	transaction.local = false;
3455	let retry = false;
3456	const doc2 = transaction.doc;
3457	const store = doc2.store;
3458	const ss = readClientsStructRefs(structDecoder, doc2);
3459	const restStructs = integrateStructs(transaction, store, ss);
3460	const pending = store.pendingStructs;
3461	if (pending) {
3462	for (const [client, clock] of pending.missing) {
3463	if (clock < getState(store, client)) {
3464	retry = true;
3465	break;
3466	}
3467	}
3468	if (restStructs) {
3469	for (const [client, clock] of restStructs.missing) {
3470	const mclock = pending.missing.get(client);
3471	if (mclock == null \|\| mclock > clock) {
3472	pending.missing.set(client, clock);
3473	}
3474	}
3475	pending.update = mergeUpdatesV2([pending.update, restStructs.update]);
3476	}
3477	} else {
3478	store.pendingStructs = restStructs;
3479	}
3480	const dsRest = readAndApplyDeleteSet(structDecoder, transaction, store);
3481	if (store.pendingDs) {
3482	const pendingDSUpdate = new UpdateDecoderV2(createDecoder(store.pendingDs));
3483	readVarUint(pendingDSUpdate.restDecoder);
3484	const dsRest2 = readAndApplyDeleteSet(pendingDSUpdate, transaction, store);
3485	if (dsRest && dsRest2) {
3486	store.pendingDs = mergeUpdatesV2([dsRest, dsRest2]);
3487	} else {
3488	store.pendingDs = dsRest \|\| dsRest2;
3489	}
3490	} else {
3491	store.pendingDs = dsRest;
3492	}
3493	if (retry) {
3494	const update = (
3495	/** @type {{update: Uint8Array}} */
3496	store.pendingStructs.update
3497	);
3498	store.pendingStructs = null;
3499	applyUpdateV2(transaction.doc, update);
3500	}
3501	}, transactionOrigin, false);
3502	var readUpdate = (decoder, ydoc, transactionOrigin) => readUpdateV2(decoder, ydoc, transactionOrigin, new UpdateDecoderV1(decoder));
3503	var applyUpdateV2 = (ydoc, update, transactionOrigin, YDecoder = UpdateDecoderV2) => {
3504	const decoder = createDecoder(update);
3505	readUpdateV2(decoder, ydoc, transactionOrigin, new YDecoder(decoder));
3506	};
3507	var applyUpdate = (ydoc, update, transactionOrigin) => applyUpdateV2(ydoc, update, transactionOrigin, UpdateDecoderV1);
3508	var writeStateAsUpdate = (encoder, doc2, targetStateVector = /* @__PURE__ */ new Map()) => {
3509	writeClientsStructs(encoder, doc2.store, targetStateVector);
3510	writeDeleteSet(encoder, createDeleteSetFromStructStore(doc2.store));
3511	};
3512	var encodeStateAsUpdateV2 = (doc2, encodedTargetStateVector = new Uint8Array([0]), encoder = new UpdateEncoderV2()) => {
3513	const targetStateVector = decodeStateVector(encodedTargetStateVector);
3514	writeStateAsUpdate(encoder, doc2, targetStateVector);
3515	const updates = [encoder.toUint8Array()];
3516	if (doc2.store.pendingDs) {
3517	updates.push(doc2.store.pendingDs);
3518	}
3519	if (doc2.store.pendingStructs) {
3520	updates.push(diffUpdateV2(doc2.store.pendingStructs.update, encodedTargetStateVector));
3521	}
3522	if (updates.length > 1) {
3523	if (encoder.constructor === UpdateEncoderV1) {
3524	return mergeUpdates(updates.map((update, i) => i === 0 ? update : convertUpdateFormatV2ToV1(update)));
3525	} else if (encoder.constructor === UpdateEncoderV2) {
3526	return mergeUpdatesV2(updates);
3527	}
3528	}
3529	return updates[0];
3530	};
3531	var encodeStateAsUpdate = (doc2, encodedTargetStateVector) => encodeStateAsUpdateV2(doc2, encodedTargetStateVector, new UpdateEncoderV1());
3532	var readStateVector = (decoder) => {
3533	const ss = /* @__PURE__ */ new Map();
3534	const ssLength = readVarUint(decoder.restDecoder);
3535	for (let i = 0; i < ssLength; i++) {
3536	const client = readVarUint(decoder.restDecoder);
3537	const clock = readVarUint(decoder.restDecoder);
3538	ss.set(client, clock);
3539	}
3540	return ss;
3541	};
3542	var decodeStateVector = (decodedState) => readStateVector(new DSDecoderV1(createDecoder(decodedState)));
3543	var writeStateVector = (encoder, sv) => {
3544	writeVarUint(encoder.restEncoder, sv.size);
3545	from(sv.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
3546	writeVarUint(encoder.restEncoder, client);
3547	writeVarUint(encoder.restEncoder, clock);
3548	});
3549	return encoder;
3550	};
3551	var writeDocumentStateVector = (encoder, doc2) => writeStateVector(encoder, getStateVector(doc2.store));
3552	var encodeStateVectorV2 = (doc2, encoder = new DSEncoderV2()) => {
3553	if (doc2 instanceof Map) {
3554	writeStateVector(encoder, doc2);
3555	} else {
3556	writeDocumentStateVector(encoder, doc2);
3557	}
3558	return encoder.toUint8Array();
3559	};
3560	var encodeStateVector = (doc2) => encodeStateVectorV2(doc2, new DSEncoderV1());
3561	var EventHandler = class {
3562	constructor() {
3563	this.l = [];
3564	}
3565	};
3566	var createEventHandler = () => new EventHandler();
3567	var addEventHandlerListener = (eventHandler, f) => eventHandler.l.push(f);
3568	var removeEventHandlerListener = (eventHandler, f) => {
3569	const l = eventHandler.l;
3570	const len = l.length;
3571	eventHandler.l = l.filter((g) => f !== g);
3572	if (len === eventHandler.l.length) {
3573	console.error("[yjs] Tried to remove event handler that doesn't exist.");
3574	}
3575	};
3576	var callEventHandlerListeners = (eventHandler, arg0, arg1) => callAll(eventHandler.l, [arg0, arg1]);
3577	var ID = class {
3578	/**
3579	* @param {number} client client id
3580	* @param {number} clock unique per client id, continuous number
3581	*/
3582	constructor(client, clock) {
3583	this.client = client;
3584	this.clock = clock;
3585	}
3586	};
3587	var compareIDs = (a, b) => a === b \|\| a !== null && b !== null && a.client === b.client && a.clock === b.clock;
3588	var createID = (client, clock) => new ID(client, clock);
3589	var writeID = (encoder, id2) => {
3590	writeVarUint(encoder, id2.client);
3591	writeVarUint(encoder, id2.clock);
3592	};
3593	var readID = (decoder) => createID(readVarUint(decoder), readVarUint(decoder));
3594	var findRootTypeKey = (type) => {
3595	for (const [key, value] of type.doc.share.entries()) {
3596	if (value === type) {
3597	return key;
3598	}
3599	}
3600	throw unexpectedCase();
3601	};
3602	var isParentOf = (parent, child) => {
3603	while (child !== null) {
3604	if (child.parent === parent) {
3605	return true;
3606	}
3607	child = /** @type {AbstractType<any>} */
3608	child.parent._item;
3609	}
3610	return false;
3611	};
3612	var logType = (type) => {
3613	const res = [];
3614	let n = type._start;
3615	while (n) {
3616	res.push(n);
3617	n = n.right;
3618	}
3619	console.log("Children: ", res);
3620	console.log("Children content: ", res.filter((m) => !m.deleted).map((m) => m.content));
3621	};
3622	var PermanentUserData = class {
3623	/**
3624	* @param {Doc} doc
3625	* @param {YMap<any>} [storeType]
3626	*/
3627	constructor(doc2, storeType = doc2.getMap("users")) {
3628	const dss = /* @__PURE__ */ new Map();
3629	this.yusers = storeType;
3630	this.doc = doc2;
3631	this.clients = /* @__PURE__ */ new Map();
3632	this.dss = dss;
3633	const initUser = (user, userDescription) => {
3634	const ds = user.get("ds");
3635	const ids = user.get("ids");
3636	const addClientId = (
3637	/** @param {number} clientid */
3638	(clientid) => this.clients.set(clientid, userDescription)
3639	);
3640	ds.observe(
3641	/** @param {YArrayEvent<any>} event */
3642	(event) => {
3643	event.changes.added.forEach((item) => {
3644	item.content.getContent().forEach((encodedDs) => {
3645	if (encodedDs instanceof Uint8Array) {
3646	this.dss.set(userDescription, mergeDeleteSets([this.dss.get(userDescription) \|\| createDeleteSet(), readDeleteSet(new DSDecoderV1(createDecoder(encodedDs)))]));
3647	}
3648	});
3649	});
3650	}
3651	);
3652	this.dss.set(userDescription, mergeDeleteSets(ds.map((encodedDs) => readDeleteSet(new DSDecoderV1(createDecoder(encodedDs))))));
3653	ids.observe(
3654	/** @param {YArrayEvent<any>} event */
3655	(event) => event.changes.added.forEach((item) => item.content.getContent().forEach(addClientId))
3656	);
3657	ids.forEach(addClientId);
3658	};
3659	storeType.observe((event) => {
3660	event.keysChanged.forEach(
3661	(userDescription) => initUser(storeType.get(userDescription), userDescription)
3662	);
3663	});
3664	storeType.forEach(initUser);
3665	}
3666	/**
3667	* @param {Doc} doc
3668	* @param {number} clientid
3669	* @param {string} userDescription
3670	* @param {Object} conf
3671	* @param {function(Transaction, DeleteSet):boolean} [conf.filter]
3672	*/
3673	setUserMapping(doc2, clientid, userDescription, { filter = () => true } = {}) {
3674	const users = this.yusers;
3675	let user = users.get(userDescription);
3676	if (!user) {
3677	user = new YMap();
3678	user.set("ids", new YArray());
3679	user.set("ds", new YArray());
3680	users.set(userDescription, user);
3681	}
3682	user.get("ids").push([clientid]);
3683	users.observe((_event) => {
3684	setTimeout(() => {
3685	const userOverwrite = users.get(userDescription);
3686	if (userOverwrite !== user) {
3687	user = userOverwrite;
3688	this.clients.forEach((_userDescription, clientid2) => {
3689	if (userDescription === _userDescription) {
3690	user.get("ids").push([clientid2]);
3691	}
3692	});
3693	const encoder = new DSEncoderV1();
3694	const ds = this.dss.get(userDescription);
3695	if (ds) {
3696	writeDeleteSet(encoder, ds);
3697	user.get("ds").push([encoder.toUint8Array()]);
3698	}
3699	}
3700	}, 0);
3701	});
3702	doc2.on(
3703	"afterTransaction",
3704	/** @param {Transaction} transaction */
3705	(transaction) => {
3706	setTimeout(() => {
3707	const yds = user.get("ds");
3708	const ds = transaction.deleteSet;
3709	if (transaction.local && ds.clients.size > 0 && filter(transaction, ds)) {
3710	const encoder = new DSEncoderV1();
3711	writeDeleteSet(encoder, ds);
3712	yds.push([encoder.toUint8Array()]);
3713	}
3714	});
3715	}
3716	);
3717	}
3718	/**
3719	* @param {number} clientid
3720	* @return {any}
3721	*/
3722	getUserByClientId(clientid) {
3723	return this.clients.get(clientid) \|\| null;
3724	}
3725	/**
3726	* @param {ID} id
3727	* @return {string \| null}
3728	*/
3729	getUserByDeletedId(id2) {
3730	for (const [userDescription, ds] of this.dss.entries()) {
3731	if (isDeleted(ds, id2)) {
3732	return userDescription;
3733	}
3734	}
3735	return null;
3736	}
3737	};
3738	var RelativePosition = class {
3739	/**
3740	* @param {ID\|null} type
3741	* @param {string\|null} tname
3742	* @param {ID\|null} item
3743	* @param {number} assoc
3744	*/
3745	constructor(type, tname, item, assoc = 0) {
3746	this.type = type;
3747	this.tname = tname;
3748	this.item = item;
3749	this.assoc = assoc;
3750	}
3751	};
3752	var relativePositionToJSON = (rpos) => {
3753	const json = {};
3754	if (rpos.type) {
3755	json.type = rpos.type;
3756	}
3757	if (rpos.tname) {
3758	json.tname = rpos.tname;
3759	}
3760	if (rpos.item) {
3761	json.item = rpos.item;
3762	}
3763	if (rpos.assoc != null) {
3764	json.assoc = rpos.assoc;
3765	}
3766	return json;
3767	};
3768	var createRelativePositionFromJSON = (json) => new RelativePosition(json.type == null ? null : createID(json.type.client, json.type.clock), json.tname ?? null, json.item == null ? null : createID(json.item.client, json.item.clock), json.assoc == null ? 0 : json.assoc);
3769	var AbsolutePosition = class {
3770	/**
3771	* @param {AbstractType<any>} type
3772	* @param {number} index
3773	* @param {number} [assoc]
3774	*/
3775	constructor(type, index, assoc = 0) {
3776	this.type = type;
3777	this.index = index;
3778	this.assoc = assoc;
3779	}
3780	};
3781	var createAbsolutePosition = (type, index, assoc = 0) => new AbsolutePosition(type, index, assoc);
3782	var createRelativePosition = (type, item, assoc) => {
3783	let typeid = null;
3784	let tname = null;
3785	if (type._item === null) {
3786	tname = findRootTypeKey(type);
3787	} else {
3788	typeid = createID(type._item.id.client, type._item.id.clock);
3789	}
3790	return new RelativePosition(typeid, tname, item, assoc);
3791	};
3792	var createRelativePositionFromTypeIndex = (type, index, assoc = 0) => {
3793	let t = type._start;
3794	if (assoc < 0) {
3795	if (index === 0) {
3796	return createRelativePosition(type, null, assoc);
3797	}
3798	index--;
3799	}
3800	while (t !== null) {
3801	if (!t.deleted && t.countable) {
3802	if (t.length > index) {
3803	return createRelativePosition(type, createID(t.id.client, t.id.clock + index), assoc);
3804	}
3805	index -= t.length;
3806	}
3807	if (t.right === null && assoc < 0) {
3808	return createRelativePosition(type, t.lastId, assoc);
3809	}
3810	t = t.right;
3811	}
3812	return createRelativePosition(type, null, assoc);
3813	};
3814	var writeRelativePosition = (encoder, rpos) => {
3815	const { type, tname, item, assoc } = rpos;
3816	if (item !== null) {
3817	writeVarUint(encoder, 0);
3818	writeID(encoder, item);
3819	} else if (tname !== null) {
3820	writeUint8(encoder, 1);
3821	writeVarString(encoder, tname);
3822	} else if (type !== null) {
3823	writeUint8(encoder, 2);
3824	writeID(encoder, type);
3825	} else {
3826	throw unexpectedCase();
3827	}
3828	writeVarInt(encoder, assoc);
3829	return encoder;
3830	};
3831	var encodeRelativePosition = (rpos) => {
3832	const encoder = createEncoder();
3833	writeRelativePosition(encoder, rpos);
3834	return toUint8Array(encoder);
3835	};
3836	var readRelativePosition = (decoder) => {
3837	let type = null;
3838	let tname = null;
3839	let itemID = null;
3840	switch (readVarUint(decoder)) {
3841	case 0:
3842	itemID = readID(decoder);
3843	break;
3844	case 1:
3845	tname = readVarString(decoder);
3846	break;
3847	case 2: {
3848	type = readID(decoder);
3849	}
3850	}
3851	const assoc = hasContent(decoder) ? readVarInt(decoder) : 0;
3852	return new RelativePosition(type, tname, itemID, assoc);
3853	};
3854	var decodeRelativePosition = (uint8Array) => readRelativePosition(createDecoder(uint8Array));
3855	var getItemWithOffset = (store, id2) => {
3856	const item = getItem(store, id2);
3857	const diff = id2.clock - item.id.clock;
3858	return {
3859	item,
3860	diff
3861	};
3862	};
3863	var createAbsolutePositionFromRelativePosition = (rpos, doc2, followUndoneDeletions = true) => {
3864	const store = doc2.store;
3865	const rightID = rpos.item;
3866	const typeID = rpos.type;
3867	const tname = rpos.tname;
3868	const assoc = rpos.assoc;
3869	let type = null;
3870	let index = 0;
3871	if (rightID !== null) {
3872	if (getState(store, rightID.client) <= rightID.clock) {
3873	return null;
3874	}
3875	const res = followUndoneDeletions ? followRedone(store, rightID) : getItemWithOffset(store, rightID);
3876	const right = res.item;
3877	if (!(right instanceof Item)) {
3878	return null;
3879	}
3880	type = /** @type {AbstractType<any>} */
3881	right.parent;
3882	if (type._item === null \|\| !type._item.deleted) {
3883	index = right.deleted \|\| !right.countable ? 0 : res.diff + (assoc >= 0 ? 0 : 1);
3884	let n = right.left;
3885	while (n !== null) {
3886	if (!n.deleted && n.countable) {
3887	index += n.length;
3888	}
3889	n = n.left;
3890	}
3891	}
3892	} else {
3893	if (tname !== null) {
3894	type = doc2.get(tname);
3895	} else if (typeID !== null) {
3896	if (getState(store, typeID.client) <= typeID.clock) {
3897	return null;
3898	}
3899	const { item } = followUndoneDeletions ? followRedone(store, typeID) : { item: getItem(store, typeID) };
3900	if (item instanceof Item && item.content instanceof ContentType) {
3901	type = item.content.type;
3902	} else {
3903	return null;
3904	}
3905	} else {
3906	throw unexpectedCase();
3907	}
3908	if (assoc >= 0) {
3909	index = type._length;
3910	} else {
3911	index = 0;
3912	}
3913	}
3914	return createAbsolutePosition(type, index, rpos.assoc);
3915	};
3916	var compareRelativePositions = (a, b) => a === b \|\| a !== null && b !== null && a.tname === b.tname && compareIDs(a.item, b.item) && compareIDs(a.type, b.type) && a.assoc === b.assoc;
3917	var Snapshot = class {
3918	/**
3919	* @param {DeleteSet} ds
3920	* @param {Map<number,number>} sv state map
3921	*/
3922	constructor(ds, sv) {
3923	this.ds = ds;
3924	this.sv = sv;
3925	}
3926	};
3927	var equalSnapshots = (snap1, snap2) => {
3928	const ds1 = snap1.ds.clients;
3929	const ds2 = snap2.ds.clients;
3930	const sv1 = snap1.sv;
3931	const sv2 = snap2.sv;
3932	if (sv1.size !== sv2.size \|\| ds1.size !== ds2.size) {
3933	return false;
3934	}
3935	for (const [key, value] of sv1.entries()) {
3936	if (sv2.get(key) !== value) {
3937	return false;
3938	}
3939	}
3940	for (const [client, dsitems1] of ds1.entries()) {
3941	const dsitems2 = ds2.get(client) \|\| [];
3942	if (dsitems1.length !== dsitems2.length) {
3943	return false;
3944	}
3945	for (let i = 0; i < dsitems1.length; i++) {
3946	const dsitem1 = dsitems1[i];
3947	const dsitem2 = dsitems2[i];
3948	if (dsitem1.clock !== dsitem2.clock \|\| dsitem1.len !== dsitem2.len) {
3949	return false;
3950	}
3951	}
3952	}
3953	return true;
3954	};
3955	var encodeSnapshotV2 = (snapshot2, encoder = new DSEncoderV2()) => {
3956	writeDeleteSet(encoder, snapshot2.ds);
3957	writeStateVector(encoder, snapshot2.sv);
3958	return encoder.toUint8Array();
3959	};
3960	var encodeSnapshot = (snapshot2) => encodeSnapshotV2(snapshot2, new DSEncoderV1());
3961	var decodeSnapshotV2 = (buf, decoder = new DSDecoderV2(createDecoder(buf))) => {
3962	return new Snapshot(readDeleteSet(decoder), readStateVector(decoder));
3963	};
3964	var decodeSnapshot = (buf) => decodeSnapshotV2(buf, new DSDecoderV1(createDecoder(buf)));
3965	var createSnapshot = (ds, sm) => new Snapshot(ds, sm);
3966	var emptySnapshot = createSnapshot(createDeleteSet(), /* @__PURE__ */ new Map());
3967	var snapshot = (doc2) => createSnapshot(createDeleteSetFromStructStore(doc2.store), getStateVector(doc2.store));
3968	var isVisible = (item, snapshot2) => snapshot2 === void 0 ? !item.deleted : snapshot2.sv.has(item.id.client) && (snapshot2.sv.get(item.id.client) \|\| 0) > item.id.clock && !isDeleted(snapshot2.ds, item.id);
3969	var splitSnapshotAffectedStructs = (transaction, snapshot2) => {
3970	const meta = setIfUndefined(transaction.meta, splitSnapshotAffectedStructs, create2);
3971	const store = transaction.doc.store;
3972	if (!meta.has(snapshot2)) {
3973	snapshot2.sv.forEach((clock, client) => {
3974	if (clock < getState(store, client)) {
3975	getItemCleanStart(transaction, createID(client, clock));
3976	}
3977	});
3978	iterateDeletedStructs(transaction, snapshot2.ds, (_item) => {
3979	});
3980	meta.add(snapshot2);
3981	}
3982	};
3983	var createDocFromSnapshot = (originDoc, snapshot2, newDoc = new Doc()) => {
3984	if (originDoc.gc) {
3985	throw new Error("Garbage-collection must be disabled in `originDoc`!");
3986	}
3987	const { sv, ds } = snapshot2;
3988	const encoder = new UpdateEncoderV2();
3989	originDoc.transact((transaction) => {
3990	let size2 = 0;
3991	sv.forEach((clock) => {
3992	if (clock > 0) {
3993	size2++;
3994	}
3995	});
3996	writeVarUint(encoder.restEncoder, size2);
3997	for (const [client, clock] of sv) {
3998	if (clock === 0) {
3999	continue;
4000	}
4001	if (clock < getState(originDoc.store, client)) {
4002	getItemCleanStart(transaction, createID(client, clock));
4003	}
4004	const structs = originDoc.store.clients.get(client) \|\| [];
4005	const lastStructIndex = findIndexSS(structs, clock - 1);
4006	writeVarUint(encoder.restEncoder, lastStructIndex + 1);
4007	encoder.writeClient(client);
4008	writeVarUint(encoder.restEncoder, 0);
4009	for (let i = 0; i <= lastStructIndex; i++) {
4010	structs[i].write(encoder, 0);
4011	}
4012	}
4013	writeDeleteSet(encoder, ds);
4014	});
4015	applyUpdateV2(newDoc, encoder.toUint8Array(), "snapshot");
4016	return newDoc;
4017	};
4018	var snapshotContainsUpdateV2 = (snapshot2, update, YDecoder = UpdateDecoderV2) => {
4019	const updateDecoder = new YDecoder(createDecoder(update));
4020	const lazyDecoder = new LazyStructReader(updateDecoder, false);
4021	for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
4022	if ((snapshot2.sv.get(curr.id.client) \|\| 0) < curr.id.clock + curr.length) {
4023	return false;
4024	}
4025	}
4026	const mergedDS = mergeDeleteSets([snapshot2.ds, readDeleteSet(updateDecoder)]);
4027	return equalDeleteSets(snapshot2.ds, mergedDS);
4028	};
4029	var snapshotContainsUpdate = (snapshot2, update) => snapshotContainsUpdateV2(snapshot2, update, UpdateDecoderV1);
4030	var StructStore = class {
4031	constructor() {
4032	this.clients = /* @__PURE__ */ new Map();
4033	this.pendingStructs = null;
4034	this.pendingDs = null;
4035	}
4036	};
4037	var getStateVector = (store) => {
4038	const sm = /* @__PURE__ */ new Map();
4039	store.clients.forEach((structs, client) => {
4040	const struct = structs[structs.length - 1];
4041	sm.set(client, struct.id.clock + struct.length);
4042	});
4043	return sm;
4044	};
4045	var getState = (store, client) => {
4046	const structs = store.clients.get(client);
4047	if (structs === void 0) {
4048	return 0;
4049	}
4050	const lastStruct = structs[structs.length - 1];
4051	return lastStruct.id.clock + lastStruct.length;
4052	};
4053	var addStruct = (store, struct) => {
4054	let structs = store.clients.get(struct.id.client);
4055	if (structs === void 0) {
4056	structs = [];
4057	store.clients.set(struct.id.client, structs);
4058	} else {
4059	const lastStruct = structs[structs.length - 1];
4060	if (lastStruct.id.clock + lastStruct.length !== struct.id.clock) {
4061	throw unexpectedCase();
4062	}
4063	}
4064	structs.push(struct);
4065	};
4066	var findIndexSS = (structs, clock) => {
4067	let left = 0;
4068	let right = structs.length - 1;
4069	let mid = structs[right];
4070	let midclock = mid.id.clock;
4071	if (midclock === clock) {
4072	return right;
4073	}
4074	let midindex = floor(clock / (midclock + mid.length - 1) * right);
4075	while (left <= right) {
4076	mid = structs[midindex];
4077	midclock = mid.id.clock;
4078	if (midclock <= clock) {
4079	if (clock < midclock + mid.length) {
4080	return midindex;
4081	}
4082	left = midindex + 1;
4083	} else {
4084	right = midindex - 1;
4085	}
4086	midindex = floor((left + right) / 2);
4087	}
4088	throw unexpectedCase();
4089	};
4090	var find = (store, id2) => {
4091	const structs = store.clients.get(id2.client);
4092	return structs[findIndexSS(structs, id2.clock)];
4093	};
4094	var getItem = (
4095	/** @type {function(StructStore,ID):Item} */
4096	find
4097	);
4098	var findIndexCleanStart = (transaction, structs, clock) => {
4099	const index = findIndexSS(structs, clock);
4100	const struct = structs[index];
4101	if (struct.id.clock < clock && struct instanceof Item) {
4102	structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));
4103	return index + 1;
4104	}
4105	return index;
4106	};
4107	var getItemCleanStart = (transaction, id2) => {
4108	const structs = (
4109	/** @type {Array<Item>} */
4110	transaction.doc.store.clients.get(id2.client)
4111	);
4112	return structs[findIndexCleanStart(transaction, structs, id2.clock)];
4113	};
4114	var getItemCleanEnd = (transaction, store, id2) => {
4115	const structs = store.clients.get(id2.client);
4116	const index = findIndexSS(structs, id2.clock);
4117	const struct = structs[index];
4118	if (id2.clock !== struct.id.clock + struct.length - 1 && struct.constructor !== GC) {
4119	structs.splice(index + 1, 0, splitItem(transaction, struct, id2.clock - struct.id.clock + 1));
4120	}
4121	return struct;
4122	};
4123	var replaceStruct = (store, struct, newStruct) => {
4124	const structs = (
4125	/** @type {Array<GC\|Item>} */
4126	store.clients.get(struct.id.client)
4127	);
4128	structs[findIndexSS(structs, struct.id.clock)] = newStruct;
4129	};
4130	var iterateStructs = (transaction, structs, clockStart, len, f) => {
4131	if (len === 0) {
4132	return;
4133	}
4134	const clockEnd = clockStart + len;
4135	let index = findIndexCleanStart(transaction, structs, clockStart);
4136	let struct;
4137	do {
4138	struct = structs[index++];
4139	if (clockEnd < struct.id.clock + struct.length) {
4140	findIndexCleanStart(transaction, structs, clockEnd);
4141	}
4142	f(struct);
4143	} while (index < structs.length && structs[index].id.clock < clockEnd);
4144	};
4145	var Transaction = class {
4146	/**
4147	* @param {Doc} doc
4148	* @param {any} origin
4149	* @param {boolean} local
4150	*/
4151	constructor(doc2, origin2, local) {
4152	this.doc = doc2;
4153	this.deleteSet = new DeleteSet();
4154	this.beforeState = getStateVector(doc2.store);
4155	this.afterState = /* @__PURE__ */ new Map();
4156	this.changed = /* @__PURE__ */ new Map();
4157	this.changedParentTypes = /* @__PURE__ */ new Map();
4158	this._mergeStructs = [];
4159	this.origin = origin2;
4160	this.meta = /* @__PURE__ */ new Map();
4161	this.local = local;
4162	this.subdocsAdded = /* @__PURE__ */ new Set();
4163	this.subdocsRemoved = /* @__PURE__ */ new Set();
4164	this.subdocsLoaded = /* @__PURE__ */ new Set();
4165	this._needFormattingCleanup = false;
4166	}
4167	};
4168	var writeUpdateMessageFromTransaction = (encoder, transaction) => {
4169	if (transaction.deleteSet.clients.size === 0 && !any(transaction.afterState, (clock, client) => transaction.beforeState.get(client) !== clock)) {
4170	return false;
4171	}
4172	sortAndMergeDeleteSet(transaction.deleteSet);
4173	writeStructsFromTransaction(encoder, transaction);
4174	writeDeleteSet(encoder, transaction.deleteSet);
4175	return true;
4176	};
4177	var addChangedTypeToTransaction = (transaction, type, parentSub) => {
4178	const item = type._item;
4179	if (item === null \|\| item.id.clock < (transaction.beforeState.get(item.id.client) \|\| 0) && !item.deleted) {
4180	setIfUndefined(transaction.changed, type, create2).add(parentSub);
4181	}
4182	};
4183	var tryToMergeWithLefts = (structs, pos) => {
4184	let right = structs[pos];
4185	let left = structs[pos - 1];
4186	let i = pos;
4187	for (; i > 0; right = left, left = structs[--i - 1]) {
4188	if (left.deleted === right.deleted && left.constructor === right.constructor) {
4189	if (left.mergeWith(right)) {
4190	if (right instanceof Item && right.parentSub !== null && /** @type {AbstractType<any>} */
4191	right.parent._map.get(right.parentSub) === right) {
4192	right.parent._map.set(
4193	right.parentSub,
4194	/** @type {Item} */
4195	left
4196	);
4197	}
4198	continue;
4199	}
4200	}
4201	break;
4202	}
4203	const merged = pos - i;
4204	if (merged) {
4205	structs.splice(pos + 1 - merged, merged);
4206	}
4207	return merged;
4208	};
4209	var tryGcDeleteSet = (ds, store, gcFilter) => {
4210	for (const [client, deleteItems] of ds.clients.entries()) {
4211	const structs = (
4212	/** @type {Array<GC\|Item>} */
4213	store.clients.get(client)
4214	);
4215	for (let di = deleteItems.length - 1; di >= 0; di--) {
4216	const deleteItem = deleteItems[di];
4217	const endDeleteItemClock = deleteItem.clock + deleteItem.len;
4218	for (let si = findIndexSS(structs, deleteItem.clock), struct = structs[si]; si < structs.length && struct.id.clock < endDeleteItemClock; struct = structs[++si]) {
4219	const struct2 = structs[si];
4220	if (deleteItem.clock + deleteItem.len <= struct2.id.clock) {
4221	break;
4222	}
4223	if (struct2 instanceof Item && struct2.deleted && !struct2.keep && gcFilter(struct2)) {
4224	struct2.gc(store, false);
4225	}
4226	}
4227	}
4228	}
4229	};
4230	var tryMergeDeleteSet = (ds, store) => {
4231	ds.clients.forEach((deleteItems, client) => {
4232	const structs = (
4233	/** @type {Array<GC\|Item>} */
4234	store.clients.get(client)
4235	);
4236	for (let di = deleteItems.length - 1; di >= 0; di--) {
4237	const deleteItem = deleteItems[di];
4238	const mostRightIndexToCheck = min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1));
4239	for (let si = mostRightIndexToCheck, struct = structs[si]; si > 0 && struct.id.clock >= deleteItem.clock; struct = structs[si]) {
4240	si -= 1 + tryToMergeWithLefts(structs, si);
4241	}
4242	}
4243	});
4244	};
4245	var tryGc = (ds, store, gcFilter) => {
4246	tryGcDeleteSet(ds, store, gcFilter);
4247	tryMergeDeleteSet(ds, store);
4248	};
4249	var cleanupTransactions = (transactionCleanups, i) => {
4250	if (i < transactionCleanups.length) {
4251	const transaction = transactionCleanups[i];
4252	const doc2 = transaction.doc;
4253	const store = doc2.store;
4254	const ds = transaction.deleteSet;
4255	const mergeStructs = transaction._mergeStructs;
4256	try {
4257	sortAndMergeDeleteSet(ds);
4258	transaction.afterState = getStateVector(transaction.doc.store);
4259	doc2.emit("beforeObserverCalls", [transaction, doc2]);
4260	const fs = [];
4261	transaction.changed.forEach(
4262	(subs, itemtype) => fs.push(() => {
4263	if (itemtype._item === null \|\| !itemtype._item.deleted) {
4264	itemtype._callObserver(transaction, subs);
4265	}
4266	})
4267	);
4268	fs.push(() => {
4269	transaction.changedParentTypes.forEach((events, type) => {
4270	if (type._dEH.l.length > 0 && (type._item === null \|\| !type._item.deleted)) {
4271	events = events.filter(
4272	(event) => event.target._item === null \|\| !event.target._item.deleted
4273	);
4274	events.forEach((event) => {
4275	event.currentTarget = type;
4276	event._path = null;
4277	});
4278	events.sort((event1, event2) => event1.path.length - event2.path.length);
4279	fs.push(() => {
4280	callEventHandlerListeners(type._dEH, events, transaction);
4281	});
4282	}
4283	});
4284	fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
4285	fs.push(() => {
4286	if (transaction._needFormattingCleanup) {
4287	cleanupYTextAfterTransaction(transaction);
4288	}
4289	});
4290	});
4291	callAll(fs, []);
4292	} finally {
4293	if (doc2.gc) {
4294	tryGcDeleteSet(ds, store, doc2.gcFilter);
4295	}
4296	tryMergeDeleteSet(ds, store);
4297	transaction.afterState.forEach((clock, client) => {
4298	const beforeClock = transaction.beforeState.get(client) \|\| 0;
4299	if (beforeClock !== clock) {
4300	const structs = (
4301	/** @type {Array<GC\|Item>} */
4302	store.clients.get(client)
4303	);
4304	const firstChangePos = max(findIndexSS(structs, beforeClock), 1);
4305	for (let i2 = structs.length - 1; i2 >= firstChangePos; ) {
4306	i2 -= 1 + tryToMergeWithLefts(structs, i2);
4307	}
4308	}
4309	});
4310	for (let i2 = mergeStructs.length - 1; i2 >= 0; i2--) {
4311	const { client, clock } = mergeStructs[i2].id;
4312	const structs = (
4313	/** @type {Array<GC\|Item>} */
4314	store.clients.get(client)
4315	);
4316	const replacedStructPos = findIndexSS(structs, clock);
4317	if (replacedStructPos + 1 < structs.length) {
4318	if (tryToMergeWithLefts(structs, replacedStructPos + 1) > 1) {
4319	continue;
4320	}
4321	}
4322	if (replacedStructPos > 0) {
4323	tryToMergeWithLefts(structs, replacedStructPos);
4324	}
4325	}
4326	if (!transaction.local && transaction.afterState.get(doc2.clientID) !== transaction.beforeState.get(doc2.clientID)) {
4327	print(ORANGE, BOLD, "[yjs] ", UNBOLD, RED, "Changed the client-id because another client seems to be using it.");
4328	doc2.clientID = generateNewClientId();
4329	}
4330	doc2.emit("afterTransactionCleanup", [transaction, doc2]);
4331	if (doc2._observers.has("update")) {
4332	const encoder = new UpdateEncoderV1();
4333	const hasContent2 = writeUpdateMessageFromTransaction(encoder, transaction);
4334	if (hasContent2) {
4335	doc2.emit("update", [encoder.toUint8Array(), transaction.origin, doc2, transaction]);
4336	}
4337	}
4338	if (doc2._observers.has("updateV2")) {
4339	const encoder = new UpdateEncoderV2();
4340	const hasContent2 = writeUpdateMessageFromTransaction(encoder, transaction);
4341	if (hasContent2) {
4342	doc2.emit("updateV2", [encoder.toUint8Array(), transaction.origin, doc2, transaction]);
4343	}
4344	}
4345	const { subdocsAdded, subdocsLoaded, subdocsRemoved } = transaction;
4346	if (subdocsAdded.size > 0 \|\| subdocsRemoved.size > 0 \|\| subdocsLoaded.size > 0) {
4347	subdocsAdded.forEach((subdoc) => {
4348	subdoc.clientID = doc2.clientID;
4349	if (subdoc.collectionid == null) {
4350	subdoc.collectionid = doc2.collectionid;
4351	}
4352	doc2.subdocs.add(subdoc);
4353	});
4354	subdocsRemoved.forEach((subdoc) => doc2.subdocs.delete(subdoc));
4355	doc2.emit("subdocs", [{ loaded: subdocsLoaded, added: subdocsAdded, removed: subdocsRemoved }, doc2, transaction]);
4356	subdocsRemoved.forEach((subdoc) => subdoc.destroy());
4357	}
4358	if (transactionCleanups.length <= i + 1) {
4359	doc2._transactionCleanups = [];
4360	doc2.emit("afterAllTransactions", [doc2, transactionCleanups]);
4361	} else {
4362	cleanupTransactions(transactionCleanups, i + 1);
4363	}
4364	}
4365	}
4366	};
4367	var transact = (doc2, f, origin2 = null, local = true) => {
4368	const transactionCleanups = doc2._transactionCleanups;
4369	let initialCall = false;
4370	let result = null;
4371	if (doc2._transaction === null) {
4372	initialCall = true;
4373	doc2._transaction = new Transaction(doc2, origin2, local);
4374	transactionCleanups.push(doc2._transaction);
4375	if (transactionCleanups.length === 1) {
4376	doc2.emit("beforeAllTransactions", [doc2]);
4377	}
4378	doc2.emit("beforeTransaction", [doc2._transaction, doc2]);
4379	}
4380	try {
4381	result = f(doc2._transaction);
4382	} finally {
4383	if (initialCall) {
4384	const finishCleanup = doc2._transaction === transactionCleanups[0];
4385	doc2._transaction = null;
4386	if (finishCleanup) {
4387	cleanupTransactions(transactionCleanups, 0);
4388	}
4389	}
4390	}
4391	return result;
4392	};
4393	var StackItem = class {
4394	/**
4395	* @param {DeleteSet} deletions
4396	* @param {DeleteSet} insertions
4397	*/
4398	constructor(deletions, insertions) {
4399	this.insertions = insertions;
4400	this.deletions = deletions;
4401	this.meta = /* @__PURE__ */ new Map();
4402	}
4403	};
4404	var clearUndoManagerStackItem = (tr, um, stackItem) => {
4405	iterateDeletedStructs(tr, stackItem.deletions, (item) => {
4406	if (item instanceof Item && um.scope.some((type) => type === tr.doc \|\| isParentOf(
4407	/** @type {AbstractType<any>} */
4408	type,
4409	item
4410	))) {
4411	keepItem(item, false);
4412	}
4413	});
4414	};
4415	var popStackItem = (undoManager, stack, eventType) => {
4416	let _tr = null;
4417	const doc2 = undoManager.doc;
4418	const scope = undoManager.scope;
4419	transact(doc2, (transaction) => {
4420	while (stack.length > 0 && undoManager.currStackItem === null) {
4421	const store = doc2.store;
4422	const stackItem = (
4423	/** @type {StackItem} */
4424	stack.pop()
4425	);
4426	const itemsToRedo = /* @__PURE__ */ new Set();
4427	const itemsToDelete = [];
4428	let performedChange = false;
4429	iterateDeletedStructs(transaction, stackItem.insertions, (struct) => {
4430	if (struct instanceof Item) {
4431	if (struct.redone !== null) {
4432	let { item, diff } = followRedone(store, struct.id);
4433	if (diff > 0) {
4434	item = getItemCleanStart(transaction, createID(item.id.client, item.id.clock + diff));
4435	}
4436	struct = item;
4437	}
4438	if (!struct.deleted && scope.some((type) => type === transaction.doc \|\| isParentOf(
4439	/** @type {AbstractType<any>} */
4440	type,
4441	/** @type {Item} */
4442	struct
4443	))) {
4444	itemsToDelete.push(struct);
4445	}
4446	}
4447	});
4448	iterateDeletedStructs(transaction, stackItem.deletions, (struct) => {
4449	if (struct instanceof Item && scope.some((type) => type === transaction.doc \|\| isParentOf(
4450	/** @type {AbstractType<any>} */
4451	type,
4452	struct
4453	)) && // Never redo structs in stackItem.insertions because they were created and deleted in the same capture interval.
4454	!isDeleted(stackItem.insertions, struct.id)) {
4455	itemsToRedo.add(struct);
4456	}
4457	});
4458	itemsToRedo.forEach((struct) => {
4459	performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.insertions, undoManager.ignoreRemoteMapChanges, undoManager) !== null \|\| performedChange;
4460	});
4461	for (let i = itemsToDelete.length - 1; i >= 0; i--) {
4462	const item = itemsToDelete[i];
4463	if (undoManager.deleteFilter(item)) {
4464	item.delete(transaction);
4465	performedChange = true;
4466	}
4467	}
4468	undoManager.currStackItem = performedChange ? stackItem : null;
4469	}
4470	transaction.changed.forEach((subProps, type) => {
4471	if (subProps.has(null) && type._searchMarker) {
4472	type._searchMarker.length = 0;
4473	}
4474	});
4475	_tr = transaction;
4476	}, undoManager);
4477	const res = undoManager.currStackItem;
4478	if (res != null) {
4479	const changedParentTypes = _tr.changedParentTypes;
4480	undoManager.emit("stack-item-popped", [{ stackItem: res, type: eventType, changedParentTypes, origin: undoManager }, undoManager]);
4481	undoManager.currStackItem = null;
4482	}
4483	return res;
4484	};
4485	var UndoManager = class extends ObservableV2 {
4486	/**
4487	* @param {Doc\|AbstractType<any>\|Array<AbstractType<any>>} typeScope Limits the scope of the UndoManager. If this is set to a ydoc instance, all changes on that ydoc will be undone. If set to a specific type, only changes on that type or its children will be undone. Also accepts an array of types.
4488	* @param {UndoManagerOptions} options
4489	*/
4490	constructor(typeScope, {
4491	captureTimeout = 500,
4492	captureTransaction = (_tr) => true,
4493	deleteFilter = () => true,
4494	trackedOrigins = /* @__PURE__ */ new Set([null]),
4495	ignoreRemoteMapChanges = false,
4496	doc: doc2 = (
4497	/** @type {Doc} */
4498	isArray(typeScope) ? typeScope[0].doc : typeScope instanceof Doc ? typeScope : typeScope.doc
4499	)
4500	} = {}) {
4501	super();
4502	this.scope = [];
4503	this.doc = doc2;
4504	this.addToScope(typeScope);
4505	this.deleteFilter = deleteFilter;
4506	trackedOrigins.add(this);
4507	this.trackedOrigins = trackedOrigins;
4508	this.captureTransaction = captureTransaction;
4509	this.undoStack = [];
4510	this.redoStack = [];
4511	this.undoing = false;
4512	this.redoing = false;
4513	this.currStackItem = null;
4514	this.lastChange = 0;
4515	this.ignoreRemoteMapChanges = ignoreRemoteMapChanges;
4516	this.captureTimeout = captureTimeout;
4517	this.afterTransactionHandler = (transaction) => {
4518	if (!this.captureTransaction(transaction) \|\| !this.scope.some((type) => transaction.changedParentTypes.has(
4519	/** @type {AbstractType<any>} */
4520	type
4521	) \|\| type === this.doc) \|\| !this.trackedOrigins.has(transaction.origin) && (!transaction.origin \|\| !this.trackedOrigins.has(transaction.origin.constructor))) {
4522	return;
4523	}
4524	const undoing = this.undoing;
4525	const redoing = this.redoing;
4526	const stack = undoing ? this.redoStack : this.undoStack;
4527	if (undoing) {
4528	this.stopCapturing();
4529	} else if (!redoing) {
4530	this.clear(false, true);
4531	}
4532	const insertions = new DeleteSet();
4533	transaction.afterState.forEach((endClock, client) => {
4534	const startClock = transaction.beforeState.get(client) \|\| 0;
4535	const len = endClock - startClock;
4536	if (len > 0) {
4537	addToDeleteSet(insertions, client, startClock, len);
4538	}
4539	});
4540	const now = getUnixTime();
4541	let didAdd = false;
4542	if (this.lastChange > 0 && now - this.lastChange < this.captureTimeout && stack.length > 0 && !undoing && !redoing) {
4543	const lastOp = stack[stack.length - 1];
4544	lastOp.deletions = mergeDeleteSets([lastOp.deletions, transaction.deleteSet]);
4545	lastOp.insertions = mergeDeleteSets([lastOp.insertions, insertions]);
4546	} else {
4547	stack.push(new StackItem(transaction.deleteSet, insertions));
4548	didAdd = true;
4549	}
4550	if (!undoing && !redoing) {
4551	this.lastChange = now;
4552	}
4553	iterateDeletedStructs(
4554	transaction,
4555	transaction.deleteSet,
4556	/** @param {Item\|GC} item */
4557	(item) => {
4558	if (item instanceof Item && this.scope.some((type) => type === transaction.doc \|\| isParentOf(
4559	/** @type {AbstractType<any>} */
4560	type,
4561	item
4562	))) {
4563	keepItem(item, true);
4564	}
4565	}
4566	);
4567	const changeEvent = [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? "redo" : "undo", changedParentTypes: transaction.changedParentTypes }, this];
4568	if (didAdd) {
4569	this.emit("stack-item-added", changeEvent);
4570	} else {
4571	this.emit("stack-item-updated", changeEvent);
4572	}
4573	};
4574	this.doc.on("afterTransaction", this.afterTransactionHandler);
4575	this.doc.on("destroy", () => {
4576	this.destroy();
4577	});
4578	}
4579	/**
4580	* Extend the scope.
4581	*
4582	* @param {Array<AbstractType<any> \| Doc> \| AbstractType<any> \| Doc} ytypes
4583	*/
4584	addToScope(ytypes) {
4585	const tmpSet = new Set(this.scope);
4586	ytypes = isArray(ytypes) ? ytypes : [ytypes];
4587	ytypes.forEach((ytype) => {
4588	if (!tmpSet.has(ytype)) {
4589	tmpSet.add(ytype);
4590	if (ytype instanceof AbstractType ? ytype.doc !== this.doc : ytype !== this.doc) warn("[yjs#509] Not same Y.Doc");
4591	this.scope.push(ytype);
4592	}
4593	});
4594	}
4595	/**
4596	* @param {any} origin
4597	*/
4598	addTrackedOrigin(origin2) {
4599	this.trackedOrigins.add(origin2);
4600	}
4601	/**
4602	* @param {any} origin
4603	*/
4604	removeTrackedOrigin(origin2) {
4605	this.trackedOrigins.delete(origin2);
4606	}
4607	clear(clearUndoStack = true, clearRedoStack = true) {
4608	if (clearUndoStack && this.canUndo() \|\| clearRedoStack && this.canRedo()) {
4609	this.doc.transact((tr) => {
4610	if (clearUndoStack) {
4611	this.undoStack.forEach((item) => clearUndoManagerStackItem(tr, this, item));
4612	this.undoStack = [];
4613	}
4614	if (clearRedoStack) {
4615	this.redoStack.forEach((item) => clearUndoManagerStackItem(tr, this, item));
4616	this.redoStack = [];
4617	}
4618	this.emit("stack-cleared", [{ undoStackCleared: clearUndoStack, redoStackCleared: clearRedoStack }]);
4619	});
4620	}
4621	}
4622	/**
4623	* UndoManager merges Undo-StackItem if they are created within time-gap
4624	* smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
4625	* StackItem won't be merged.
4626	*
4627	*
4628	* @example
4629	* // without stopCapturing
4630	* ytext.insert(0, 'a')
4631	* ytext.insert(1, 'b')
4632	* um.undo()
4633	* ytext.toString() // => '' (note that 'ab' was removed)
4634	* // with stopCapturing
4635	* ytext.insert(0, 'a')
4636	* um.stopCapturing()
4637	* ytext.insert(0, 'b')
4638	* um.undo()
4639	* ytext.toString() // => 'a' (note that only 'b' was removed)
4640	*
4641	*/
4642	stopCapturing() {
4643	this.lastChange = 0;
4644	}
4645	/**
4646	* Undo last changes on type.
4647	*
4648	* @return {StackItem?} Returns StackItem if a change was applied
4649	*/
4650	undo() {
4651	this.undoing = true;
4652	let res;
4653	try {
4654	res = popStackItem(this, this.undoStack, "undo");
4655	} finally {
4656	this.undoing = false;
4657	}
4658	return res;
4659	}
4660	/**
4661	* Redo last undo operation.
4662	*
4663	* @return {StackItem?} Returns StackItem if a change was applied
4664	*/
4665	redo() {
4666	this.redoing = true;
4667	let res;
4668	try {
4669	res = popStackItem(this, this.redoStack, "redo");
4670	} finally {
4671	this.redoing = false;
4672	}
4673	return res;
4674	}
4675	/**
4676	* Are undo steps available?
4677	*
4678	* @return {boolean} `true` if undo is possible
4679	*/
4680	canUndo() {
4681	return this.undoStack.length > 0;
4682	}
4683	/**
4684	* Are redo steps available?
4685	*
4686	* @return {boolean} `true` if redo is possible
4687	*/
4688	canRedo() {
4689	return this.redoStack.length > 0;
4690	}
4691	destroy() {
4692	this.trackedOrigins.delete(this);
4693	this.doc.off("afterTransaction", this.afterTransactionHandler);
4694	super.destroy();
4695	}
4696	};
4697	function* lazyStructReaderGenerator(decoder) {
4698	const numOfStateUpdates = readVarUint(decoder.restDecoder);
4699	for (let i = 0; i < numOfStateUpdates; i++) {
4700	const numberOfStructs = readVarUint(decoder.restDecoder);
4701	const client = decoder.readClient();
4702	let clock = readVarUint(decoder.restDecoder);
4703	for (let i2 = 0; i2 < numberOfStructs; i2++) {
4704	const info = decoder.readInfo();
4705	if (info === 10) {
4706	const len = readVarUint(decoder.restDecoder);
4707	yield new Skip(createID(client, clock), len);
4708	clock += len;
4709	} else if ((BITS5 & info) !== 0) {
4710	const cantCopyParentInfo = (info & (BIT7 \| BIT8)) === 0;
4711	const struct = new Item(
4712	createID(client, clock),
4713	null,
4714	// left
4715	(info & BIT8) === BIT8 ? decoder.readLeftID() : null,
4716	// origin
4717	null,
4718	// right
4719	(info & BIT7) === BIT7 ? decoder.readRightID() : null,
4720	// right origin
4721	// @ts-ignore Force writing a string here.
4722	cantCopyParentInfo ? decoder.readParentInfo() ? decoder.readString() : decoder.readLeftID() : null,
4723	// parent
4724	cantCopyParentInfo && (info & BIT6) === BIT6 ? decoder.readString() : null,
4725	// parentSub
4726	readItemContent(decoder, info)
4727	// item content
4728	);
4729	yield struct;
4730	clock += struct.length;
4731	} else {
4732	const len = decoder.readLen();
4733	yield new GC(createID(client, clock), len);
4734	clock += len;
4735	}
4736	}
4737	}
4738	}
4739	var LazyStructReader = class {
4740	/**
4741	* @param {UpdateDecoderV1 \| UpdateDecoderV2} decoder
4742	* @param {boolean} filterSkips
4743	*/
4744	constructor(decoder, filterSkips) {
4745	this.gen = lazyStructReaderGenerator(decoder);
4746	this.curr = null;
4747	this.done = false;
4748	this.filterSkips = filterSkips;
4749	this.next();
4750	}
4751	/**
4752	* @return {Item \| GC \| Skip \|null}
4753	*/
4754	next() {
4755	do {
4756	this.curr = this.gen.next().value \|\| null;
4757	} while (this.filterSkips && this.curr !== null && this.curr.constructor === Skip);
4758	return this.curr;
4759	}
4760	};
4761	var logUpdate = (update) => logUpdateV2(update, UpdateDecoderV1);
4762	var logUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
4763	const structs = [];
4764	const updateDecoder = new YDecoder(createDecoder(update));
4765	const lazyDecoder = new LazyStructReader(updateDecoder, false);
4766	for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
4767	structs.push(curr);
4768	}
4769	print("Structs: ", structs);
4770	const ds = readDeleteSet(updateDecoder);
4771	print("DeleteSet: ", ds);
4772	};
4773	var decodeUpdate = (update) => decodeUpdateV2(update, UpdateDecoderV1);
4774	var decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
4775	const structs = [];
4776	const updateDecoder = new YDecoder(createDecoder(update));
4777	const lazyDecoder = new LazyStructReader(updateDecoder, false);
4778	for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
4779	structs.push(curr);
4780	}
4781	return {
4782	structs,
4783	ds: readDeleteSet(updateDecoder)
4784	};
4785	};
4786	var LazyStructWriter = class {
4787	/**
4788	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
4789	*/
4790	constructor(encoder) {
4791	this.currClient = 0;
4792	this.startClock = 0;
4793	this.written = 0;
4794	this.encoder = encoder;
4795	this.clientStructs = [];
4796	}
4797	};
4798	var mergeUpdates = (updates) => mergeUpdatesV2(updates, UpdateDecoderV1, UpdateEncoderV1);
4799	var encodeStateVectorFromUpdateV2 = (update, YEncoder = DSEncoderV2, YDecoder = UpdateDecoderV2) => {
4800	const encoder = new YEncoder();
4801	const updateDecoder = new LazyStructReader(new YDecoder(createDecoder(update)), false);
4802	let curr = updateDecoder.curr;
4803	if (curr !== null) {
4804	let size2 = 0;
4805	let currClient = curr.id.client;
4806	let stopCounting = curr.id.clock !== 0;
4807	let currClock = stopCounting ? 0 : curr.id.clock + curr.length;
4808	for (; curr !== null; curr = updateDecoder.next()) {
4809	if (currClient !== curr.id.client) {
4810	if (currClock !== 0) {
4811	size2++;
4812	writeVarUint(encoder.restEncoder, currClient);
4813	writeVarUint(encoder.restEncoder, currClock);
4814	}
4815	currClient = curr.id.client;
4816	currClock = 0;
4817	stopCounting = curr.id.clock !== 0;
4818	}
4819	if (curr.constructor === Skip) {
4820	stopCounting = true;
4821	}
4822	if (!stopCounting) {
4823	currClock = curr.id.clock + curr.length;
4824	}
4825	}
4826	if (currClock !== 0) {
4827	size2++;
4828	writeVarUint(encoder.restEncoder, currClient);
4829	writeVarUint(encoder.restEncoder, currClock);
4830	}
4831	const enc = createEncoder();
4832	writeVarUint(enc, size2);
4833	writeBinaryEncoder(enc, encoder.restEncoder);
4834	encoder.restEncoder = enc;
4835	return encoder.toUint8Array();
4836	} else {
4837	writeVarUint(encoder.restEncoder, 0);
4838	return encoder.toUint8Array();
4839	}
4840	};
4841	var encodeStateVectorFromUpdate = (update) => encodeStateVectorFromUpdateV2(update, DSEncoderV1, UpdateDecoderV1);
4842	var parseUpdateMetaV2 = (update, YDecoder = UpdateDecoderV2) => {
4843	const from2 = /* @__PURE__ */ new Map();
4844	const to = /* @__PURE__ */ new Map();
4845	const updateDecoder = new LazyStructReader(new YDecoder(createDecoder(update)), false);
4846	let curr = updateDecoder.curr;
4847	if (curr !== null) {
4848	let currClient = curr.id.client;
4849	let currClock = curr.id.clock;
4850	from2.set(currClient, currClock);
4851	for (; curr !== null; curr = updateDecoder.next()) {
4852	if (currClient !== curr.id.client) {
4853	to.set(currClient, currClock);
4854	from2.set(curr.id.client, curr.id.clock);
4855	currClient = curr.id.client;
4856	}
4857	currClock = curr.id.clock + curr.length;
4858	}
4859	to.set(currClient, currClock);
4860	}
4861	return { from: from2, to };
4862	};
4863	var parseUpdateMeta = (update) => parseUpdateMetaV2(update, UpdateDecoderV1);
4864	var sliceStruct = (left, diff) => {
4865	if (left.constructor === GC) {
4866	const { client, clock } = left.id;
4867	return new GC(createID(client, clock + diff), left.length - diff);
4868	} else if (left.constructor === Skip) {
4869	const { client, clock } = left.id;
4870	return new Skip(createID(client, clock + diff), left.length - diff);
4871	} else {
4872	const leftItem = (
4873	/** @type {Item} */
4874	left
4875	);
4876	const { client, clock } = leftItem.id;
4877	return new Item(
4878	createID(client, clock + diff),
4879	null,
4880	createID(client, clock + diff - 1),
4881	null,
4882	leftItem.rightOrigin,
4883	leftItem.parent,
4884	leftItem.parentSub,
4885	leftItem.content.splice(diff)
4886	);
4887	}
4888	};
4889	var mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
4890	if (updates.length === 1) {
4891	return updates[0];
4892	}
4893	const updateDecoders = updates.map((update) => new YDecoder(createDecoder(update)));
4894	let lazyStructDecoders = updateDecoders.map((decoder) => new LazyStructReader(decoder, true));
4895	let currWrite = null;
4896	const updateEncoder = new YEncoder();
4897	const lazyStructEncoder = new LazyStructWriter(updateEncoder);
4898	while (true) {
4899	lazyStructDecoders = lazyStructDecoders.filter((dec) => dec.curr !== null);
4900	lazyStructDecoders.sort(
4901	/** @type {function(any,any):number} */
4902	(dec1, dec2) => {
4903	if (dec1.curr.id.client === dec2.curr.id.client) {
4904	const clockDiff = dec1.curr.id.clock - dec2.curr.id.clock;
4905	if (clockDiff === 0) {
4906	return dec1.curr.constructor === dec2.curr.constructor ? 0 : dec1.curr.constructor === Skip ? 1 : -1;
4907	} else {
4908	return clockDiff;
4909	}
4910	} else {
4911	return dec2.curr.id.client - dec1.curr.id.client;
4912	}
4913	}
4914	);
4915	if (lazyStructDecoders.length === 0) {
4916	break;
4917	}
4918	const currDecoder = lazyStructDecoders[0];
4919	const firstClient = (
4920	/** @type {Item \| GC} */
4921	currDecoder.curr.id.client
4922	);
4923	if (currWrite !== null) {
4924	let curr = (
4925	/** @type {Item \| GC \| null} */
4926	currDecoder.curr
4927	);
4928	let iterated = false;
4929	while (curr !== null && curr.id.clock + curr.length <= currWrite.struct.id.clock + currWrite.struct.length && curr.id.client >= currWrite.struct.id.client) {
4930	curr = currDecoder.next();
4931	iterated = true;
4932	}
4933	if (curr === null \|\| // current decoder is empty
4934	curr.id.client !== firstClient \|\| // check whether there is another decoder that has has updates from `firstClient`
4935	iterated && curr.id.clock > currWrite.struct.id.clock + currWrite.struct.length) {
4936	continue;
4937	}
4938	if (firstClient !== currWrite.struct.id.client) {
4939	writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4940	currWrite = { struct: curr, offset: 0 };
4941	currDecoder.next();
4942	} else {
4943	if (currWrite.struct.id.clock + currWrite.struct.length < curr.id.clock) {
4944	if (currWrite.struct.constructor === Skip) {
4945	currWrite.struct.length = curr.id.clock + curr.length - currWrite.struct.id.clock;
4946	} else {
4947	writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4948	const diff = curr.id.clock - currWrite.struct.id.clock - currWrite.struct.length;
4949	const struct = new Skip(createID(firstClient, currWrite.struct.id.clock + currWrite.struct.length), diff);
4950	currWrite = { struct, offset: 0 };
4951	}
4952	} else {
4953	const diff = currWrite.struct.id.clock + currWrite.struct.length - curr.id.clock;
4954	if (diff > 0) {
4955	if (currWrite.struct.constructor === Skip) {
4956	currWrite.struct.length -= diff;
4957	} else {
4958	curr = sliceStruct(curr, diff);
4959	}
4960	}
4961	if (!currWrite.struct.mergeWith(
4962	/** @type {any} */
4963	curr
4964	)) {
4965	writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4966	currWrite = { struct: curr, offset: 0 };
4967	currDecoder.next();
4968	}
4969	}
4970	}
4971	} else {
4972	currWrite = { struct: (
4973	/** @type {Item \| GC} */
4974	currDecoder.curr
4975	), offset: 0 };
4976	currDecoder.next();
4977	}
4978	for (let next = currDecoder.curr; next !== null && next.id.client === firstClient && next.id.clock === currWrite.struct.id.clock + currWrite.struct.length && next.constructor !== Skip; next = currDecoder.next()) {
4979	writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4980	currWrite = { struct: next, offset: 0 };
4981	}
4982	}
4983	if (currWrite !== null) {
4984	writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4985	currWrite = null;
4986	}
4987	finishLazyStructWriting(lazyStructEncoder);
4988	const dss = updateDecoders.map((decoder) => readDeleteSet(decoder));
4989	const ds = mergeDeleteSets(dss);
4990	writeDeleteSet(updateEncoder, ds);
4991	return updateEncoder.toUint8Array();
4992	};
4993	var diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
4994	const state = decodeStateVector(sv);
4995	const encoder = new YEncoder();
4996	const lazyStructWriter = new LazyStructWriter(encoder);
4997	const decoder = new YDecoder(createDecoder(update));
4998	const reader = new LazyStructReader(decoder, false);
4999	while (reader.curr) {
5000	const curr = reader.curr;
5001	const currClient = curr.id.client;
5002	const svClock = state.get(currClient) \|\| 0;
5003	if (reader.curr.constructor === Skip) {
5004	reader.next();
5005	continue;
5006	}
5007	if (curr.id.clock + curr.length > svClock) {
5008	writeStructToLazyStructWriter(lazyStructWriter, curr, max(svClock - curr.id.clock, 0));
5009	reader.next();
5010	while (reader.curr && reader.curr.id.client === currClient) {
5011	writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0);
5012	reader.next();
5013	}
5014	} else {
5015	while (reader.curr && reader.curr.id.client === currClient && reader.curr.id.clock + reader.curr.length <= svClock) {
5016	reader.next();
5017	}
5018	}
5019	}
5020	finishLazyStructWriting(lazyStructWriter);
5021	const ds = readDeleteSet(decoder);
5022	writeDeleteSet(encoder, ds);
5023	return encoder.toUint8Array();
5024	};
5025	var diffUpdate = (update, sv) => diffUpdateV2(update, sv, UpdateDecoderV1, UpdateEncoderV1);
5026	var flushLazyStructWriter = (lazyWriter) => {
5027	if (lazyWriter.written > 0) {
5028	lazyWriter.clientStructs.push({ written: lazyWriter.written, restEncoder: toUint8Array(lazyWriter.encoder.restEncoder) });
5029	lazyWriter.encoder.restEncoder = createEncoder();
5030	lazyWriter.written = 0;
5031	}
5032	};
5033	var writeStructToLazyStructWriter = (lazyWriter, struct, offset) => {
5034	if (lazyWriter.written > 0 && lazyWriter.currClient !== struct.id.client) {
5035	flushLazyStructWriter(lazyWriter);
5036	}
5037	if (lazyWriter.written === 0) {
5038	lazyWriter.currClient = struct.id.client;
5039	lazyWriter.encoder.writeClient(struct.id.client);
5040	writeVarUint(lazyWriter.encoder.restEncoder, struct.id.clock + offset);
5041	}
5042	struct.write(lazyWriter.encoder, offset);
5043	lazyWriter.written++;
5044	};
5045	var finishLazyStructWriting = (lazyWriter) => {
5046	flushLazyStructWriter(lazyWriter);
5047	const restEncoder = lazyWriter.encoder.restEncoder;
5048	writeVarUint(restEncoder, lazyWriter.clientStructs.length);
5049	for (let i = 0; i < lazyWriter.clientStructs.length; i++) {
5050	const partStructs = lazyWriter.clientStructs[i];
5051	writeVarUint(restEncoder, partStructs.written);
5052	writeUint8Array(restEncoder, partStructs.restEncoder);
5053	}
5054	};
5055	var convertUpdateFormat = (update, blockTransformer, YDecoder, YEncoder) => {
5056	const updateDecoder = new YDecoder(createDecoder(update));
5057	const lazyDecoder = new LazyStructReader(updateDecoder, false);
5058	const updateEncoder = new YEncoder();
5059	const lazyWriter = new LazyStructWriter(updateEncoder);
5060	for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
5061	writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0);
5062	}
5063	finishLazyStructWriting(lazyWriter);
5064	const ds = readDeleteSet(updateDecoder);
5065	writeDeleteSet(updateEncoder, ds);
5066	return updateEncoder.toUint8Array();
5067	};
5068	var createObfuscator = ({ formatting = true, subdocs = true, yxml = true } = {}) => {
5069	let i = 0;
5070	const mapKeyCache = create();
5071	const nodeNameCache = create();
5072	const formattingKeyCache = create();
5073	const formattingValueCache = create();
5074	formattingValueCache.set(null, null);
5075	return (block) => {
5076	switch (block.constructor) {
5077	case GC:
5078	case Skip:
5079	return block;
5080	case Item: {
5081	const item = (
5082	/** @type {Item} */
5083	block
5084	);
5085	const content = item.content;
5086	switch (content.constructor) {
5087	case ContentDeleted:
5088	break;
5089	case ContentType: {
5090	if (yxml) {
5091	const type = (
5092	/** @type {ContentType} */
5093	content.type
5094	);
5095	if (type instanceof YXmlElement) {
5096	type.nodeName = setIfUndefined(nodeNameCache, type.nodeName, () => "node-" + i);
5097	}
5098	if (type instanceof YXmlHook) {
5099	type.hookName = setIfUndefined(nodeNameCache, type.hookName, () => "hook-" + i);
5100	}
5101	}
5102	break;
5103	}
5104	case ContentAny: {
5105	const c = (
5106	/** @type {ContentAny} */
5107	content
5108	);
5109	c.arr = c.arr.map(() => i);
5110	break;
5111	}
5112	case ContentBinary: {
5113	const c = (
5114	/** @type {ContentBinary} */
5115	content
5116	);
5117	c.content = new Uint8Array([i]);
5118	break;
5119	}
5120	case ContentDoc: {
5121	const c = (
5122	/** @type {ContentDoc} */
5123	content
5124	);
5125	if (subdocs) {
5126	c.opts = {};
5127	c.doc.guid = i + "";
5128	}
5129	break;
5130	}
5131	case ContentEmbed: {
5132	const c = (
5133	/** @type {ContentEmbed} */
5134	content
5135	);
5136	c.embed = {};
5137	break;
5138	}
5139	case ContentFormat: {
5140	const c = (
5141	/** @type {ContentFormat} */
5142	content
5143	);
5144	if (formatting) {
5145	c.key = setIfUndefined(formattingKeyCache, c.key, () => i + "");
5146	c.value = setIfUndefined(formattingValueCache, c.value, () => ({ i }));
5147	}
5148	break;
5149	}
5150	case ContentJSON: {
5151	const c = (
5152	/** @type {ContentJSON} */
5153	content
5154	);
5155	c.arr = c.arr.map(() => i);
5156	break;
5157	}
5158	case ContentString: {
5159	const c = (
5160	/** @type {ContentString} */
5161	content
5162	);
5163	c.str = repeat(i % 10 + "", c.str.length);
5164	break;
5165	}
5166	default:
5167	unexpectedCase();
5168	}
5169	if (item.parentSub) {
5170	item.parentSub = setIfUndefined(mapKeyCache, item.parentSub, () => i + "");
5171	}
5172	i++;
5173	return block;
5174	}
5175	default:
5176	unexpectedCase();
5177	}
5178	};
5179	};
5180	var obfuscateUpdate = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV1, UpdateEncoderV1);
5181	var obfuscateUpdateV2 = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV2, UpdateEncoderV2);
5182	var convertUpdateFormatV1ToV2 = (update) => convertUpdateFormat(update, id, UpdateDecoderV1, UpdateEncoderV2);
5183	var convertUpdateFormatV2ToV1 = (update) => convertUpdateFormat(update, id, UpdateDecoderV2, UpdateEncoderV1);
5184	var errorComputeChanges = "You must not compute changes after the event-handler fired.";
5185	var YEvent = class {
5186	/**
5187	* @param {T} target The changed type.
5188	* @param {Transaction} transaction
5189	*/
5190	constructor(target, transaction) {
5191	this.target = target;
5192	this.currentTarget = target;
5193	this.transaction = transaction;
5194	this._changes = null;
5195	this._keys = null;
5196	this._delta = null;
5197	this._path = null;
5198	}
5199	/**
5200	* Computes the path from `y` to the changed type.
5201	*
5202	* @todo v14 should standardize on path: Array<{parent, index}> because that is easier to work with.
5203	*
5204	* The following property holds:
5205	* @example
5206	* let type = y
5207	* event.path.forEach(dir => {
5208	* type = type.get(dir)
5209	* })
5210	* type === event.target // => true
5211	*/
5212	get path() {
5213	return this._path \|\| (this._path = getPathTo(this.currentTarget, this.target));
5214	}
5215	/**
5216	* Check if a struct is deleted by this event.
5217	*
5218	* In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
5219	*
5220	* @param {AbstractStruct} struct
5221	* @return {boolean}
5222	*/
5223	deletes(struct) {
5224	return isDeleted(this.transaction.deleteSet, struct.id);
5225	}
5226	/**
5227	* @type {Map<string, { action: 'add' \| 'update' \| 'delete', oldValue: any }>}
5228	*/
5229	get keys() {
5230	if (this._keys === null) {
5231	if (this.transaction.doc._transactionCleanups.length === 0) {
5232	throw create3(errorComputeChanges);
5233	}
5234	const keys2 = /* @__PURE__ */ new Map();
5235	const target = this.target;
5236	const changed = (
5237	/** @type Set<string\|null> */
5238	this.transaction.changed.get(target)
5239	);
5240	changed.forEach((key) => {
5241	if (key !== null) {
5242	const item = (
5243	/** @type {Item} */
5244	target._map.get(key)
5245	);
5246	let action;
5247	let oldValue;
5248	if (this.adds(item)) {
5249	let prev = item.left;
5250	while (prev !== null && this.adds(prev)) {
5251	prev = prev.left;
5252	}
5253	if (this.deletes(item)) {
5254	if (prev !== null && this.deletes(prev)) {
5255	action = "delete";
5256	oldValue = last(prev.content.getContent());
5257	} else {
5258	return;
5259	}
5260	} else {
5261	if (prev !== null && this.deletes(prev)) {
5262	action = "update";
5263	oldValue = last(prev.content.getContent());
5264	} else {
5265	action = "add";
5266	oldValue = void 0;
5267	}
5268	}
5269	} else {
5270	if (this.deletes(item)) {
5271	action = "delete";
5272	oldValue = last(
5273	/** @type {Item} */
5274	item.content.getContent()
5275	);
5276	} else {
5277	return;
5278	}
5279	}
5280	keys2.set(key, { action, oldValue });
5281	}
5282	});
5283	this._keys = keys2;
5284	}
5285	return this._keys;
5286	}
5287	/**
5288	* This is a computed property. Note that this can only be safely computed during the
5289	* event call. Computing this property after other changes happened might result in
5290	* unexpected behavior (incorrect computation of deltas). A safe way to collect changes
5291	* is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.
5292	*
5293	* @type {Array<{insert?: string \| Array<any> \| object \| AbstractType<any>, retain?: number, delete?: number, attributes?: Object<string, any>}>}
5294	*/
5295	get delta() {
5296	return this.changes.delta;
5297	}
5298	/**
5299	* Check if a struct is added by this event.
5300	*
5301	* In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
5302	*
5303	* @param {AbstractStruct} struct
5304	* @return {boolean}
5305	*/
5306	adds(struct) {
5307	return struct.id.clock >= (this.transaction.beforeState.get(struct.id.client) \|\| 0);
5308	}
5309	/**
5310	* This is a computed property. Note that this can only be safely computed during the
5311	* event call. Computing this property after other changes happened might result in
5312	* unexpected behavior (incorrect computation of deltas). A safe way to collect changes
5313	* is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.
5314	*
5315	* @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'\|'update'\|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>\|string, delete?:number, retain?:number}>}}
5316	*/
5317	get changes() {
5318	let changes = this._changes;
5319	if (changes === null) {
5320	if (this.transaction.doc._transactionCleanups.length === 0) {
5321	throw create3(errorComputeChanges);
5322	}
5323	const target = this.target;
5324	const added = create2();
5325	const deleted = create2();
5326	const delta = [];
5327	changes = {
5328	added,
5329	deleted,
5330	delta,
5331	keys: this.keys
5332	};
5333	const changed = (
5334	/** @type Set<string\|null> */
5335	this.transaction.changed.get(target)
5336	);
5337	if (changed.has(null)) {
5338	let lastOp = null;
5339	const packOp = () => {
5340	if (lastOp) {
5341	delta.push(lastOp);
5342	}
5343	};
5344	for (let item = target._start; item !== null; item = item.right) {
5345	if (item.deleted) {
5346	if (this.deletes(item) && !this.adds(item)) {
5347	if (lastOp === null \|\| lastOp.delete === void 0) {
5348	packOp();
5349	lastOp = { delete: 0 };
5350	}
5351	lastOp.delete += item.length;
5352	deleted.add(item);
5353	}
5354	} else {
5355	if (this.adds(item)) {
5356	if (lastOp === null \|\| lastOp.insert === void 0) {
5357	packOp();
5358	lastOp = { insert: [] };
5359	}
5360	lastOp.insert = lastOp.insert.concat(item.content.getContent());
5361	added.add(item);
5362	} else {
5363	if (lastOp === null \|\| lastOp.retain === void 0) {
5364	packOp();
5365	lastOp = { retain: 0 };
5366	}
5367	lastOp.retain += item.length;
5368	}
5369	}
5370	}
5371	if (lastOp !== null && lastOp.retain === void 0) {
5372	packOp();
5373	}
5374	}
5375	this._changes = changes;
5376	}
5377	return (
5378	/** @type {any} */
5379	changes
5380	);
5381	}
5382	};
5383	var getPathTo = (parent, child) => {
5384	const path = [];
5385	while (child._item !== null && child !== parent) {
5386	if (child._item.parentSub !== null) {
5387	path.unshift(child._item.parentSub);
5388	} else {
5389	let i = 0;
5390	let c = (
5391	/** @type {AbstractType<any>} */
5392	child._item.parent._start
5393	);
5394	while (c !== child._item && c !== null) {
5395	if (!c.deleted && c.countable) {
5396	i += c.length;
5397	}
5398	c = c.right;
5399	}
5400	path.unshift(i);
5401	}
5402	child = /** @type {AbstractType<any>} */
5403	child._item.parent;
5404	}
5405	return path;
5406	};
5407	var warnPrematureAccess = () => {
5408	warn("Invalid access: Add Yjs type to a document before reading data.");
5409	};
5410	var maxSearchMarker = 80;
5411	var globalSearchMarkerTimestamp = 0;
5412	var ArraySearchMarker = class {
5413	/**
5414	* @param {Item} p
5415	* @param {number} index
5416	*/
5417	constructor(p, index) {
5418	p.marker = true;
5419	this.p = p;
5420	this.index = index;
5421	this.timestamp = globalSearchMarkerTimestamp++;
5422	}
5423	};
5424	var refreshMarkerTimestamp = (marker) => {
5425	marker.timestamp = globalSearchMarkerTimestamp++;
5426	};
5427	var overwriteMarker = (marker, p, index) => {
5428	marker.p.marker = false;
5429	marker.p = p;
5430	p.marker = true;
5431	marker.index = index;
5432	marker.timestamp = globalSearchMarkerTimestamp++;
5433	};
5434	var markPosition = (searchMarker, p, index) => {
5435	if (searchMarker.length >= maxSearchMarker) {
5436	const marker = searchMarker.reduce((a, b) => a.timestamp < b.timestamp ? a : b);
5437	overwriteMarker(marker, p, index);
5438	return marker;
5439	} else {
5440	const pm = new ArraySearchMarker(p, index);
5441	searchMarker.push(pm);
5442	return pm;
5443	}
5444	};
5445	var findMarker = (yarray, index) => {
5446	if (yarray._start === null \|\| index === 0 \|\| yarray._searchMarker === null) {
5447	return null;
5448	}
5449	const marker = yarray._searchMarker.length === 0 ? null : yarray._searchMarker.reduce((a, b) => abs(index - a.index) < abs(index - b.index) ? a : b);
5450	let p = yarray._start;
5451	let pindex = 0;
5452	if (marker !== null) {
5453	p = marker.p;
5454	pindex = marker.index;
5455	refreshMarkerTimestamp(marker);
5456	}
5457	while (p.right !== null && pindex < index) {
5458	if (!p.deleted && p.countable) {
5459	if (index < pindex + p.length) {
5460	break;
5461	}
5462	pindex += p.length;
5463	}
5464	p = p.right;
5465	}
5466	while (p.left !== null && pindex > index) {
5467	p = p.left;
5468	if (!p.deleted && p.countable) {
5469	pindex -= p.length;
5470	}
5471	}
5472	while (p.left !== null && p.left.id.client === p.id.client && p.left.id.clock + p.left.length === p.id.clock) {
5473	p = p.left;
5474	if (!p.deleted && p.countable) {
5475	pindex -= p.length;
5476	}
5477	}
5478	if (marker !== null && abs(marker.index - pindex) < /** @type {YText\|YArray<any>} */
5479	p.parent.length / maxSearchMarker) {
5480	overwriteMarker(marker, p, pindex);
5481	return marker;
5482	} else {
5483	return markPosition(yarray._searchMarker, p, pindex);
5484	}
5485	};
5486	var updateMarkerChanges = (searchMarker, index, len) => {
5487	for (let i = searchMarker.length - 1; i >= 0; i--) {
5488	const m = searchMarker[i];
5489	if (len > 0) {
5490	let p = m.p;
5491	p.marker = false;
5492	while (p && (p.deleted \|\| !p.countable)) {
5493	p = p.left;
5494	if (p && !p.deleted && p.countable) {
5495	m.index -= p.length;
5496	}
5497	}
5498	if (p === null \|\| p.marker === true) {
5499	searchMarker.splice(i, 1);
5500	continue;
5501	}
5502	m.p = p;
5503	p.marker = true;
5504	}
5505	if (index < m.index \|\| len > 0 && index === m.index) {
5506	m.index = max(index, m.index + len);
5507	}
5508	}
5509	};
5510	var getTypeChildren = (t) => {
5511	t.doc ?? warnPrematureAccess();
5512	let s = t._start;
5513	const arr = [];
5514	while (s) {
5515	arr.push(s);
5516	s = s.right;
5517	}
5518	return arr;
5519	};
5520	var callTypeObservers = (type, transaction, event) => {
5521	const changedType = type;
5522	const changedParentTypes = transaction.changedParentTypes;
5523	while (true) {
5524	setIfUndefined(changedParentTypes, type, () => []).push(event);
5525	if (type._item === null) {
5526	break;
5527	}
5528	type = /** @type {AbstractType<any>} */
5529	type._item.parent;
5530	}
5531	callEventHandlerListeners(changedType._eH, event, transaction);
5532	};
5533	var AbstractType = class {
5534	constructor() {
5535	this._item = null;
5536	this._map = /* @__PURE__ */ new Map();
5537	this._start = null;
5538	this.doc = null;
5539	this._length = 0;
5540	this._eH = createEventHandler();
5541	this._dEH = createEventHandler();
5542	this._searchMarker = null;
5543	}
5544	/**
5545	* @return {AbstractType<any>\|null}
5546	*/
5547	get parent() {
5548	return this._item ? (
5549	/** @type {AbstractType<any>} */
5550	this._item.parent
5551	) : null;
5552	}
5553	/**
5554	* Integrate this type into the Yjs instance.
5555	*
5556	* * Save this struct in the os
5557	* * This type is sent to other client
5558	* * Observer functions are fired
5559	*
5560	* @param {Doc} y The Yjs instance
5561	* @param {Item\|null} item
5562	*/
5563	_integrate(y, item) {
5564	this.doc = y;
5565	this._item = item;
5566	}
5567	/**
5568	* @return {AbstractType<EventType>}
5569	*/
5570	_copy() {
5571	throw methodUnimplemented();
5572	}
5573	/**
5574	* Makes a copy of this data type that can be included somewhere else.
5575	*
5576	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
5577	*
5578	* @return {AbstractType<EventType>}
5579	*/
5580	clone() {
5581	throw methodUnimplemented();
5582	}
5583	/**
5584	* @param {UpdateEncoderV1 \| UpdateEncoderV2} _encoder
5585	*/
5586	_write(_encoder) {
5587	}
5588	/**
5589	* The first non-deleted item
5590	*/
5591	get _first() {
5592	let n = this._start;
5593	while (n !== null && n.deleted) {
5594	n = n.right;
5595	}
5596	return n;
5597	}
5598	/**
5599	* Creates YEvent and calls all type observers.
5600	* Must be implemented by each type.
5601	*
5602	* @param {Transaction} transaction
5603	* @param {Set<null\|string>} _parentSubs Keys changed on this type. `null` if list was modified.
5604	*/
5605	_callObserver(transaction, _parentSubs) {
5606	if (!transaction.local && this._searchMarker) {
5607	this._searchMarker.length = 0;
5608	}
5609	}
5610	/**
5611	* Observe all events that are created on this type.
5612	*
5613	* @param {function(EventType, Transaction):void} f Observer function
5614	*/
5615	observe(f) {
5616	addEventHandlerListener(this._eH, f);
5617	}
5618	/**
5619	* Observe all events that are created by this type and its children.
5620	*
5621	* @param {function(Array<YEvent<any>>,Transaction):void} f Observer function
5622	*/
5623	observeDeep(f) {
5624	addEventHandlerListener(this._dEH, f);
5625	}
5626	/**
5627	* Unregister an observer function.
5628	*
5629	* @param {function(EventType,Transaction):void} f Observer function
5630	*/
5631	unobserve(f) {
5632	removeEventHandlerListener(this._eH, f);
5633	}
5634	/**
5635	* Unregister an observer function.
5636	*
5637	* @param {function(Array<YEvent<any>>,Transaction):void} f Observer function
5638	*/
5639	unobserveDeep(f) {
5640	removeEventHandlerListener(this._dEH, f);
5641	}
5642	/**
5643	* @abstract
5644	* @return {any}
5645	*/
5646	toJSON() {
5647	}
5648	};
5649	var typeListSlice = (type, start, end) => {
5650	type.doc ?? warnPrematureAccess();
5651	if (start < 0) {
5652	start = type._length + start;
5653	}
5654	if (end < 0) {
5655	end = type._length + end;
5656	}
5657	let len = end - start;
5658	const cs = [];
5659	let n = type._start;
5660	while (n !== null && len > 0) {
5661	if (n.countable && !n.deleted) {
5662	const c = n.content.getContent();
5663	if (c.length <= start) {
5664	start -= c.length;
5665	} else {
5666	for (let i = start; i < c.length && len > 0; i++) {
5667	cs.push(c[i]);
5668	len--;
5669	}
5670	start = 0;
5671	}
5672	}
5673	n = n.right;
5674	}
5675	return cs;
5676	};
5677	var typeListToArray = (type) => {
5678	type.doc ?? warnPrematureAccess();
5679	const cs = [];
5680	let n = type._start;
5681	while (n !== null) {
5682	if (n.countable && !n.deleted) {
5683	const c = n.content.getContent();
5684	for (let i = 0; i < c.length; i++) {
5685	cs.push(c[i]);
5686	}
5687	}
5688	n = n.right;
5689	}
5690	return cs;
5691	};
5692	var typeListToArraySnapshot = (type, snapshot2) => {
5693	const cs = [];
5694	let n = type._start;
5695	while (n !== null) {
5696	if (n.countable && isVisible(n, snapshot2)) {
5697	const c = n.content.getContent();
5698	for (let i = 0; i < c.length; i++) {
5699	cs.push(c[i]);
5700	}
5701	}
5702	n = n.right;
5703	}
5704	return cs;
5705	};
5706	var typeListForEach = (type, f) => {
5707	let index = 0;
5708	let n = type._start;
5709	type.doc ?? warnPrematureAccess();
5710	while (n !== null) {
5711	if (n.countable && !n.deleted) {
5712	const c = n.content.getContent();
5713	for (let i = 0; i < c.length; i++) {
5714	f(c[i], index++, type);
5715	}
5716	}
5717	n = n.right;
5718	}
5719	};
5720	var typeListMap = (type, f) => {
5721	const result = [];
5722	typeListForEach(type, (c, i) => {
5723	result.push(f(c, i, type));
5724	});
5725	return result;
5726	};
5727	var typeListCreateIterator = (type) => {
5728	let n = type._start;
5729	let currentContent = null;
5730	let currentContentIndex = 0;
5731	return {
5732	[Symbol.iterator]() {
5733	return this;
5734	},
5735	next: () => {
5736	if (currentContent === null) {
5737	while (n !== null && n.deleted) {
5738	n = n.right;
5739	}
5740	if (n === null) {
5741	return {
5742	done: true,
5743	value: void 0
5744	};
5745	}
5746	currentContent = n.content.getContent();
5747	currentContentIndex = 0;
5748	n = n.right;
5749	}
5750	const value = currentContent[currentContentIndex++];
5751	if (currentContent.length <= currentContentIndex) {
5752	currentContent = null;
5753	}
5754	return {
5755	done: false,
5756	value
5757	};
5758	}
5759	};
5760	};
5761	var typeListGet = (type, index) => {
5762	type.doc ?? warnPrematureAccess();
5763	const marker = findMarker(type, index);
5764	let n = type._start;
5765	if (marker !== null) {
5766	n = marker.p;
5767	index -= marker.index;
5768	}
5769	for (; n !== null; n = n.right) {
5770	if (!n.deleted && n.countable) {
5771	if (index < n.length) {
5772	return n.content.getContent()[index];
5773	}
5774	index -= n.length;
5775	}
5776	}
5777	};
5778	var typeListInsertGenericsAfter = (transaction, parent, referenceItem, content) => {
5779	let left = referenceItem;
5780	const doc2 = transaction.doc;
5781	const ownClientId = doc2.clientID;
5782	const store = doc2.store;
5783	const right = referenceItem === null ? parent._start : referenceItem.right;
5784	let jsonContent = [];
5785	const packJsonContent = () => {
5786	if (jsonContent.length > 0) {
5787	left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentAny(jsonContent));
5788	left.integrate(transaction, 0);
5789	jsonContent = [];
5790	}
5791	};
5792	content.forEach((c) => {
5793	if (c === null) {
5794	jsonContent.push(c);
5795	} else {
5796	switch (c.constructor) {
5797	case Number:
5798	case Object:
5799	case Boolean:
5800	case Array:
5801	case String:
5802	jsonContent.push(c);
5803	break;
5804	default:
5805	packJsonContent();
5806	switch (c.constructor) {
5807	case Uint8Array:
5808	case ArrayBuffer:
5809	left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentBinary(new Uint8Array(
5810	/** @type {Uint8Array} */
5811	c
5812	)));
5813	left.integrate(transaction, 0);
5814	break;
5815	case Doc:
5816	left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentDoc(
5817	/** @type {Doc} */
5818	c
5819	));
5820	left.integrate(transaction, 0);
5821	break;
5822	default:
5823	if (c instanceof AbstractType) {
5824	left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentType(c));
5825	left.integrate(transaction, 0);
5826	} else {
5827	throw new Error("Unexpected content type in insert operation");
5828	}
5829	}
5830	}
5831	}
5832	});
5833	packJsonContent();
5834	};
5835	var lengthExceeded = () => create3("Length exceeded!");
5836	var typeListInsertGenerics = (transaction, parent, index, content) => {
5837	if (index > parent._length) {
5838	throw lengthExceeded();
5839	}
5840	if (index === 0) {
5841	if (parent._searchMarker) {
5842	updateMarkerChanges(parent._searchMarker, index, content.length);
5843	}
5844	return typeListInsertGenericsAfter(transaction, parent, null, content);
5845	}
5846	const startIndex = index;
5847	const marker = findMarker(parent, index);
5848	let n = parent._start;
5849	if (marker !== null) {
5850	n = marker.p;
5851	index -= marker.index;
5852	if (index === 0) {
5853	n = n.prev;
5854	index += n && n.countable && !n.deleted ? n.length : 0;
5855	}
5856	}
5857	for (; n !== null; n = n.right) {
5858	if (!n.deleted && n.countable) {
5859	if (index <= n.length) {
5860	if (index < n.length) {
5861	getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index));
5862	}
5863	break;
5864	}
5865	index -= n.length;
5866	}
5867	}
5868	if (parent._searchMarker) {
5869	updateMarkerChanges(parent._searchMarker, startIndex, content.length);
5870	}
5871	return typeListInsertGenericsAfter(transaction, parent, n, content);
5872	};
5873	var typeListPushGenerics = (transaction, parent, content) => {
5874	const marker = (parent._searchMarker \|\| []).reduce((maxMarker, currMarker) => currMarker.index > maxMarker.index ? currMarker : maxMarker, { index: 0, p: parent._start });
5875	let n = marker.p;
5876	if (n) {
5877	while (n.right) {
5878	n = n.right;
5879	}
5880	}
5881	return typeListInsertGenericsAfter(transaction, parent, n, content);
5882	};
5883	var typeListDelete = (transaction, parent, index, length2) => {
5884	if (length2 === 0) {
5885	return;
5886	}
5887	const startIndex = index;
5888	const startLength = length2;
5889	const marker = findMarker(parent, index);
5890	let n = parent._start;
5891	if (marker !== null) {
5892	n = marker.p;
5893	index -= marker.index;
5894	}
5895	for (; n !== null && index > 0; n = n.right) {
5896	if (!n.deleted && n.countable) {
5897	if (index < n.length) {
5898	getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index));
5899	}
5900	index -= n.length;
5901	}
5902	}
5903	while (length2 > 0 && n !== null) {
5904	if (!n.deleted) {
5905	if (length2 < n.length) {
5906	getItemCleanStart(transaction, createID(n.id.client, n.id.clock + length2));
5907	}
5908	n.delete(transaction);
5909	length2 -= n.length;
5910	}
5911	n = n.right;
5912	}
5913	if (length2 > 0) {
5914	throw lengthExceeded();
5915	}
5916	if (parent._searchMarker) {
5917	updateMarkerChanges(
5918	parent._searchMarker,
5919	startIndex,
5920	-startLength + length2
5921	/* in case we remove the above exception */
5922	);
5923	}
5924	};
5925	var typeMapDelete = (transaction, parent, key) => {
5926	const c = parent._map.get(key);
5927	if (c !== void 0) {
5928	c.delete(transaction);
5929	}
5930	};
5931	var typeMapSet = (transaction, parent, key, value) => {
5932	const left = parent._map.get(key) \|\| null;
5933	const doc2 = transaction.doc;
5934	const ownClientId = doc2.clientID;
5935	let content;
5936	if (value == null) {
5937	content = new ContentAny([value]);
5938	} else {
5939	switch (value.constructor) {
5940	case Number:
5941	case Object:
5942	case Boolean:
5943	case Array:
5944	case String:
5945	case Date:
5946	case BigInt:
5947	content = new ContentAny([value]);
5948	break;
5949	case Uint8Array:
5950	content = new ContentBinary(
5951	/** @type {Uint8Array} */
5952	value
5953	);
5954	break;
5955	case Doc:
5956	content = new ContentDoc(
5957	/** @type {Doc} */
5958	value
5959	);
5960	break;
5961	default:
5962	if (value instanceof AbstractType) {
5963	content = new ContentType(value);
5964	} else {
5965	throw new Error("Unexpected content type");
5966	}
5967	}
5968	}
5969	new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, null, null, parent, key, content).integrate(transaction, 0);
5970	};
5971	var typeMapGet = (parent, key) => {
5972	parent.doc ?? warnPrematureAccess();
5973	const val = parent._map.get(key);
5974	return val !== void 0 && !val.deleted ? val.content.getContent()[val.length - 1] : void 0;
5975	};
5976	var typeMapGetAll = (parent) => {
5977	const res = {};
5978	parent.doc ?? warnPrematureAccess();
5979	parent._map.forEach((value, key) => {
5980	if (!value.deleted) {
5981	res[key] = value.content.getContent()[value.length - 1];
5982	}
5983	});
5984	return res;
5985	};
5986	var typeMapHas = (parent, key) => {
5987	parent.doc ?? warnPrematureAccess();
5988	const val = parent._map.get(key);
5989	return val !== void 0 && !val.deleted;
5990	};
5991	var typeMapGetSnapshot = (parent, key, snapshot2) => {
5992	let v = parent._map.get(key) \|\| null;
5993	while (v !== null && (!snapshot2.sv.has(v.id.client) \|\| v.id.clock >= (snapshot2.sv.get(v.id.client) \|\| 0))) {
5994	v = v.left;
5995	}
5996	return v !== null && isVisible(v, snapshot2) ? v.content.getContent()[v.length - 1] : void 0;
5997	};
5998	var typeMapGetAllSnapshot = (parent, snapshot2) => {
5999	const res = {};
6000	parent._map.forEach((value, key) => {
6001	let v = value;
6002	while (v !== null && (!snapshot2.sv.has(v.id.client) \|\| v.id.clock >= (snapshot2.sv.get(v.id.client) \|\| 0))) {
6003	v = v.left;
6004	}
6005	if (v !== null && isVisible(v, snapshot2)) {
6006	res[key] = v.content.getContent()[v.length - 1];
6007	}
6008	});
6009	return res;
6010	};
6011	var createMapIterator = (type) => {
6012	type.doc ?? warnPrematureAccess();
6013	return iteratorFilter(
6014	type._map.entries(),
6015	/** @param {any} entry */
6016	(entry) => !entry[1].deleted
6017	);
6018	};
6019	var YArrayEvent = class extends YEvent {
6020	};
6021	var YArray = class _YArray extends AbstractType {
6022	constructor() {
6023	super();
6024	this._prelimContent = [];
6025	this._searchMarker = [];
6026	}
6027	/**
6028	* Construct a new YArray containing the specified items.
6029	* @template {Object<string,any>\|Array<any>\|number\|null\|string\|Uint8Array} T
6030	* @param {Array<T>} items
6031	* @return {YArray<T>}
6032	*/
6033	static from(items) {
6034	const a = new _YArray();
6035	a.push(items);
6036	return a;
6037	}
6038	/**
6039	* Integrate this type into the Yjs instance.
6040	*
6041	* * Save this struct in the os
6042	* * This type is sent to other client
6043	* * Observer functions are fired
6044	*
6045	* @param {Doc} y The Yjs instance
6046	* @param {Item} item
6047	*/
6048	_integrate(y, item) {
6049	super._integrate(y, item);
6050	this.insert(
6051	0,
6052	/** @type {Array<any>} */
6053	this._prelimContent
6054	);
6055	this._prelimContent = null;
6056	}
6057	/**
6058	* @return {YArray<T>}
6059	*/
6060	_copy() {
6061	return new _YArray();
6062	}
6063	/**
6064	* Makes a copy of this data type that can be included somewhere else.
6065	*
6066	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
6067	*
6068	* @return {YArray<T>}
6069	*/
6070	clone() {
6071	const arr = new _YArray();
6072	arr.insert(0, this.toArray().map(
6073	(el) => el instanceof AbstractType ? (
6074	/** @type {typeof el} */
6075	el.clone()
6076	) : el
6077	));
6078	return arr;
6079	}
6080	get length() {
6081	this.doc ?? warnPrematureAccess();
6082	return this._length;
6083	}
6084	/**
6085	* Creates YArrayEvent and calls observers.
6086	*
6087	* @param {Transaction} transaction
6088	* @param {Set<null\|string>} parentSubs Keys changed on this type. `null` if list was modified.
6089	*/
6090	_callObserver(transaction, parentSubs) {
6091	super._callObserver(transaction, parentSubs);
6092	callTypeObservers(this, transaction, new YArrayEvent(this, transaction));
6093	}
6094	/**
6095	* Inserts new content at an index.
6096	*
6097	* Important: This function expects an array of content. Not just a content
6098	* object. The reason for this "weirdness" is that inserting several elements
6099	* is very efficient when it is done as a single operation.
6100	*
6101	* @example
6102	* // Insert character 'a' at position 0
6103	* yarray.insert(0, ['a'])
6104	* // Insert numbers 1, 2 at position 1
6105	* yarray.insert(1, [1, 2])
6106	*
6107	* @param {number} index The index to insert content at.
6108	* @param {Array<T>} content The array of content
6109	*/
6110	insert(index, content) {
6111	if (this.doc !== null) {
6112	transact(this.doc, (transaction) => {
6113	typeListInsertGenerics(
6114	transaction,
6115	this,
6116	index,
6117	/** @type {any} */
6118	content
6119	);
6120	});
6121	} else {
6122	this._prelimContent.splice(index, 0, ...content);
6123	}
6124	}
6125	/**
6126	* Appends content to this YArray.
6127	*
6128	* @param {Array<T>} content Array of content to append.
6129	*
6130	* @todo Use the following implementation in all types.
6131	*/
6132	push(content) {
6133	if (this.doc !== null) {
6134	transact(this.doc, (transaction) => {
6135	typeListPushGenerics(
6136	transaction,
6137	this,
6138	/** @type {any} */
6139	content
6140	);
6141	});
6142	} else {
6143	this._prelimContent.push(...content);
6144	}
6145	}
6146	/**
6147	* Prepends content to this YArray.
6148	*
6149	* @param {Array<T>} content Array of content to prepend.
6150	*/
6151	unshift(content) {
6152	this.insert(0, content);
6153	}
6154	/**
6155	* Deletes elements starting from an index.
6156	*
6157	* @param {number} index Index at which to start deleting elements
6158	* @param {number} length The number of elements to remove. Defaults to 1.
6159	*/
6160	delete(index, length2 = 1) {
6161	if (this.doc !== null) {
6162	transact(this.doc, (transaction) => {
6163	typeListDelete(transaction, this, index, length2);
6164	});
6165	} else {
6166	this._prelimContent.splice(index, length2);
6167	}
6168	}
6169	/**
6170	* Returns the i-th element from a YArray.
6171	*
6172	* @param {number} index The index of the element to return from the YArray
6173	* @return {T}
6174	*/
6175	get(index) {
6176	return typeListGet(this, index);
6177	}
6178	/**
6179	* Transforms this YArray to a JavaScript Array.
6180	*
6181	* @return {Array<T>}
6182	*/
6183	toArray() {
6184	return typeListToArray(this);
6185	}
6186	/**
6187	* Returns a portion of this YArray into a JavaScript Array selected
6188	* from start to end (end not included).
6189	*
6190	* @param {number} [start]
6191	* @param {number} [end]
6192	* @return {Array<T>}
6193	*/
6194	slice(start = 0, end = this.length) {
6195	return typeListSlice(this, start, end);
6196	}
6197	/**
6198	* Transforms this Shared Type to a JSON object.
6199	*
6200	* @return {Array<any>}
6201	*/
6202	toJSON() {
6203	return this.map((c) => c instanceof AbstractType ? c.toJSON() : c);
6204	}
6205	/**
6206	* Returns an Array with the result of calling a provided function on every
6207	* element of this YArray.
6208	*
6209	* @template M
6210	* @param {function(T,number,YArray<T>):M} f Function that produces an element of the new Array
6211	* @return {Array<M>} A new array with each element being the result of the
6212	* callback function
6213	*/
6214	map(f) {
6215	return typeListMap(
6216	this,
6217	/** @type {any} */
6218	f
6219	);
6220	}
6221	/**
6222	* Executes a provided function once on every element of this YArray.
6223	*
6224	* @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.
6225	*/
6226	forEach(f) {
6227	typeListForEach(this, f);
6228	}
6229	/**
6230	* @return {IterableIterator<T>}
6231	*/
6232	[Symbol.iterator]() {
6233	return typeListCreateIterator(this);
6234	}
6235	/**
6236	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
6237	*/
6238	_write(encoder) {
6239	encoder.writeTypeRef(YArrayRefID);
6240	}
6241	};
6242	var readYArray = (_decoder) => new YArray();
6243	var YMapEvent = class extends YEvent {
6244	/**
6245	* @param {YMap<T>} ymap The YArray that changed.
6246	* @param {Transaction} transaction
6247	* @param {Set<any>} subs The keys that changed.
6248	*/
6249	constructor(ymap, transaction, subs) {
6250	super(ymap, transaction);
6251	this.keysChanged = subs;
6252	}
6253	};
6254	var YMap = class _YMap extends AbstractType {
6255	/**
6256	*
6257	* @param {Iterable<readonly [string, any]>=} entries - an optional iterable to initialize the YMap
6258	*/
6259	constructor(entries) {
6260	super();
6261	this._prelimContent = null;
6262	if (entries === void 0) {
6263	this._prelimContent = /* @__PURE__ */ new Map();
6264	} else {
6265	this._prelimContent = new Map(entries);
6266	}
6267	}
6268	/**
6269	* Integrate this type into the Yjs instance.
6270	*
6271	* * Save this struct in the os
6272	* * This type is sent to other client
6273	* * Observer functions are fired
6274	*
6275	* @param {Doc} y The Yjs instance
6276	* @param {Item} item
6277	*/
6278	_integrate(y, item) {
6279	super._integrate(y, item);
6280	this._prelimContent.forEach((value, key) => {
6281	this.set(key, value);
6282	});
6283	this._prelimContent = null;
6284	}
6285	/**
6286	* @return {YMap<MapType>}
6287	*/
6288	_copy() {
6289	return new _YMap();
6290	}
6291	/**
6292	* Makes a copy of this data type that can be included somewhere else.
6293	*
6294	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
6295	*
6296	* @return {YMap<MapType>}
6297	*/
6298	clone() {
6299	const map2 = new _YMap();
6300	this.forEach((value, key) => {
6301	map2.set(key, value instanceof AbstractType ? (
6302	/** @type {typeof value} */
6303	value.clone()
6304	) : value);
6305	});
6306	return map2;
6307	}
6308	/**
6309	* Creates YMapEvent and calls observers.
6310	*
6311	* @param {Transaction} transaction
6312	* @param {Set<null\|string>} parentSubs Keys changed on this type. `null` if list was modified.
6313	*/
6314	_callObserver(transaction, parentSubs) {
6315	callTypeObservers(this, transaction, new YMapEvent(this, transaction, parentSubs));
6316	}
6317	/**
6318	* Transforms this Shared Type to a JSON object.
6319	*
6320	* @return {Object<string,any>}
6321	*/
6322	toJSON() {
6323	this.doc ?? warnPrematureAccess();
6324	const map2 = {};
6325	this._map.forEach((item, key) => {
6326	if (!item.deleted) {
6327	const v = item.content.getContent()[item.length - 1];
6328	map2[key] = v instanceof AbstractType ? v.toJSON() : v;
6329	}
6330	});
6331	return map2;
6332	}
6333	/**
6334	* Returns the size of the YMap (count of key/value pairs)
6335	*
6336	* @return {number}
6337	*/
6338	get size() {
6339	return [...createMapIterator(this)].length;
6340	}
6341	/**
6342	* Returns the keys for each element in the YMap Type.
6343	*
6344	* @return {IterableIterator<string>}
6345	*/
6346	keys() {
6347	return iteratorMap(
6348	createMapIterator(this),
6349	/** @param {any} v */
6350	(v) => v[0]
6351	);
6352	}
6353	/**
6354	* Returns the values for each element in the YMap Type.
6355	*
6356	* @return {IterableIterator<MapType>}
6357	*/
6358	values() {
6359	return iteratorMap(
6360	createMapIterator(this),
6361	/** @param {any} v */
6362	(v) => v[1].content.getContent()[v[1].length - 1]
6363	);
6364	}
6365	/**
6366	* Returns an Iterator of [key, value] pairs
6367	*
6368	* @return {IterableIterator<[string, MapType]>}
6369	*/
6370	entries() {
6371	return iteratorMap(
6372	createMapIterator(this),
6373	/** @param {any} v */
6374	(v) => (
6375	/** @type {any} */
6376	[v[0], v[1].content.getContent()[v[1].length - 1]]
6377	)
6378	);
6379	}
6380	/**
6381	* Executes a provided function on once on every key-value pair.
6382	*
6383	* @param {function(MapType,string,YMap<MapType>):void} f A function to execute on every element of this YArray.
6384	*/
6385	forEach(f) {
6386	this.doc ?? warnPrematureAccess();
6387	this._map.forEach((item, key) => {
6388	if (!item.deleted) {
6389	f(item.content.getContent()[item.length - 1], key, this);
6390	}
6391	});
6392	}
6393	/**
6394	* Returns an Iterator of [key, value] pairs
6395	*
6396	* @return {IterableIterator<[string, MapType]>}
6397	*/
6398	[Symbol.iterator]() {
6399	return this.entries();
6400	}
6401	/**
6402	* Remove a specified element from this YMap.
6403	*
6404	* @param {string} key The key of the element to remove.
6405	*/
6406	delete(key) {
6407	if (this.doc !== null) {
6408	transact(this.doc, (transaction) => {
6409	typeMapDelete(transaction, this, key);
6410	});
6411	} else {
6412	this._prelimContent.delete(key);
6413	}
6414	}
6415	/**
6416	* Adds or updates an element with a specified key and value.
6417	* @template {MapType} VAL
6418	*
6419	* @param {string} key The key of the element to add to this YMap
6420	* @param {VAL} value The value of the element to add
6421	* @return {VAL}
6422	*/
6423	set(key, value) {
6424	if (this.doc !== null) {
6425	transact(this.doc, (transaction) => {
6426	typeMapSet(
6427	transaction,
6428	this,
6429	key,
6430	/** @type {any} */
6431	value
6432	);
6433	});
6434	} else {
6435	this._prelimContent.set(key, value);
6436	}
6437	return value;
6438	}
6439	/**
6440	* Returns a specified element from this YMap.
6441	*
6442	* @param {string} key
6443	* @return {MapType\|undefined}
6444	*/
6445	get(key) {
6446	return (
6447	/** @type {any} */
6448	typeMapGet(this, key)
6449	);
6450	}
6451	/**
6452	* Returns a boolean indicating whether the specified key exists or not.
6453	*
6454	* @param {string} key The key to test.
6455	* @return {boolean}
6456	*/
6457	has(key) {
6458	return typeMapHas(this, key);
6459	}
6460	/**
6461	* Removes all elements from this YMap.
6462	*/
6463	clear() {
6464	if (this.doc !== null) {
6465	transact(this.doc, (transaction) => {
6466	this.forEach(function(_value, key, map2) {
6467	typeMapDelete(transaction, map2, key);
6468	});
6469	});
6470	} else {
6471	this._prelimContent.clear();
6472	}
6473	}
6474	/**
6475	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
6476	*/
6477	_write(encoder) {
6478	encoder.writeTypeRef(YMapRefID);
6479	}
6480	};
6481	var readYMap = (_decoder) => new YMap();
6482	var equalAttrs = (a, b) => a === b \|\| typeof a === "object" && typeof b === "object" && a && b && equalFlat(a, b);
6483	var ItemTextListPosition = class {
6484	/**
6485	* @param {Item\|null} left
6486	* @param {Item\|null} right
6487	* @param {number} index
6488	* @param {Map<string,any>} currentAttributes
6489	*/
6490	constructor(left, right, index, currentAttributes) {
6491	this.left = left;
6492	this.right = right;
6493	this.index = index;
6494	this.currentAttributes = currentAttributes;
6495	}
6496	/**
6497	* Only call this if you know that this.right is defined
6498	*/
6499	forward() {
6500	if (this.right === null) {
6501	unexpectedCase();
6502	}
6503	switch (this.right.content.constructor) {
6504	case ContentFormat:
6505	if (!this.right.deleted) {
6506	updateCurrentAttributes(
6507	this.currentAttributes,
6508	/** @type {ContentFormat} */
6509	this.right.content
6510	);
6511	}
6512	break;
6513	default:
6514	if (!this.right.deleted) {
6515	this.index += this.right.length;
6516	}
6517	break;
6518	}
6519	this.left = this.right;
6520	this.right = this.right.right;
6521	}
6522	};
6523	var findNextPosition = (transaction, pos, count) => {
6524	while (pos.right !== null && count > 0) {
6525	switch (pos.right.content.constructor) {
6526	case ContentFormat:
6527	if (!pos.right.deleted) {
6528	updateCurrentAttributes(
6529	pos.currentAttributes,
6530	/** @type {ContentFormat} */
6531	pos.right.content
6532	);
6533	}
6534	break;
6535	default:
6536	if (!pos.right.deleted) {
6537	if (count < pos.right.length) {
6538	getItemCleanStart(transaction, createID(pos.right.id.client, pos.right.id.clock + count));
6539	}
6540	pos.index += pos.right.length;
6541	count -= pos.right.length;
6542	}
6543	break;
6544	}
6545	pos.left = pos.right;
6546	pos.right = pos.right.right;
6547	}
6548	return pos;
6549	};
6550	var findPosition = (transaction, parent, index, useSearchMarker) => {
6551	const currentAttributes = /* @__PURE__ */ new Map();
6552	const marker = useSearchMarker ? findMarker(parent, index) : null;
6553	if (marker) {
6554	const pos = new ItemTextListPosition(marker.p.left, marker.p, marker.index, currentAttributes);
6555	return findNextPosition(transaction, pos, index - marker.index);
6556	} else {
6557	const pos = new ItemTextListPosition(null, parent._start, 0, currentAttributes);
6558	return findNextPosition(transaction, pos, index);
6559	}
6560	};
6561	var insertNegatedAttributes = (transaction, parent, currPos, negatedAttributes) => {
6562	while (currPos.right !== null && (currPos.right.deleted === true \|\| currPos.right.content.constructor === ContentFormat && equalAttrs(
6563	negatedAttributes.get(
6564	/** @type {ContentFormat} */
6565	currPos.right.content.key
6566	),
6567	/** @type {ContentFormat} */
6568	currPos.right.content.value
6569	))) {
6570	if (!currPos.right.deleted) {
6571	negatedAttributes.delete(
6572	/** @type {ContentFormat} */
6573	currPos.right.content.key
6574	);
6575	}
6576	currPos.forward();
6577	}
6578	const doc2 = transaction.doc;
6579	const ownClientId = doc2.clientID;
6580	negatedAttributes.forEach((val, key) => {
6581	const left = currPos.left;
6582	const right = currPos.right;
6583	const nextFormat = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentFormat(key, val));
6584	nextFormat.integrate(transaction, 0);
6585	currPos.right = nextFormat;
6586	currPos.forward();
6587	});
6588	};
6589	var updateCurrentAttributes = (currentAttributes, format) => {
6590	const { key, value } = format;
6591	if (value === null) {
6592	currentAttributes.delete(key);
6593	} else {
6594	currentAttributes.set(key, value);
6595	}
6596	};
6597	var minimizeAttributeChanges = (currPos, attributes) => {
6598	while (true) {
6599	if (currPos.right === null) {
6600	break;
6601	} else if (currPos.right.deleted \|\| currPos.right.content.constructor === ContentFormat && equalAttrs(
6602	attributes[
6603	/** @type {ContentFormat} */
6604	currPos.right.content.key
6605	] ?? null,
6606	/** @type {ContentFormat} */
6607	currPos.right.content.value
6608	)) ;
6609	else {
6610	break;
6611	}
6612	currPos.forward();
6613	}
6614	};
6615	var insertAttributes = (transaction, parent, currPos, attributes) => {
6616	const doc2 = transaction.doc;
6617	const ownClientId = doc2.clientID;
6618	const negatedAttributes = /* @__PURE__ */ new Map();
6619	for (const key in attributes) {
6620	const val = attributes[key];
6621	const currentVal = currPos.currentAttributes.get(key) ?? null;
6622	if (!equalAttrs(currentVal, val)) {
6623	negatedAttributes.set(key, currentVal);
6624	const { left, right } = currPos;
6625	currPos.right = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentFormat(key, val));
6626	currPos.right.integrate(transaction, 0);
6627	currPos.forward();
6628	}
6629	}
6630	return negatedAttributes;
6631	};
6632	var insertText = (transaction, parent, currPos, text2, attributes) => {
6633	currPos.currentAttributes.forEach((_val, key) => {
6634	if (attributes[key] === void 0) {
6635	attributes[key] = null;
6636	}
6637	});
6638	const doc2 = transaction.doc;
6639	const ownClientId = doc2.clientID;
6640	minimizeAttributeChanges(currPos, attributes);
6641	const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes);
6642	const content = text2.constructor === String ? new ContentString(
6643	/** @type {string} */
6644	text2
6645	) : text2 instanceof AbstractType ? new ContentType(text2) : new ContentEmbed(text2);
6646	let { left, right, index } = currPos;
6647	if (parent._searchMarker) {
6648	updateMarkerChanges(parent._searchMarker, currPos.index, content.getLength());
6649	}
6650	right = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, content);
6651	right.integrate(transaction, 0);
6652	currPos.right = right;
6653	currPos.index = index;
6654	currPos.forward();
6655	insertNegatedAttributes(transaction, parent, currPos, negatedAttributes);
6656	};
6657	var formatText = (transaction, parent, currPos, length2, attributes) => {
6658	const doc2 = transaction.doc;
6659	const ownClientId = doc2.clientID;
6660	minimizeAttributeChanges(currPos, attributes);
6661	const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes);
6662	iterationLoop: while (currPos.right !== null && (length2 > 0 \|\| negatedAttributes.size > 0 && (currPos.right.deleted \|\| currPos.right.content.constructor === ContentFormat))) {
6663	if (!currPos.right.deleted) {
6664	switch (currPos.right.content.constructor) {
6665	case ContentFormat: {
6666	const { key, value } = (
6667	/** @type {ContentFormat} */
6668	currPos.right.content
6669	);
6670	const attr = attributes[key];
6671	if (attr !== void 0) {
6672	if (equalAttrs(attr, value)) {
6673	negatedAttributes.delete(key);
6674	} else {
6675	if (length2 === 0) {
6676	break iterationLoop;
6677	}
6678	negatedAttributes.set(key, value);
6679	}
6680	currPos.right.delete(transaction);
6681	} else {
6682	currPos.currentAttributes.set(key, value);
6683	}
6684	break;
6685	}
6686	default:
6687	if (length2 < currPos.right.length) {
6688	getItemCleanStart(transaction, createID(currPos.right.id.client, currPos.right.id.clock + length2));
6689	}
6690	length2 -= currPos.right.length;
6691	break;
6692	}
6693	}
6694	currPos.forward();
6695	}
6696	if (length2 > 0) {
6697	let newlines = "";
6698	for (; length2 > 0; length2--) {
6699	newlines += "\n";
6700	}
6701	currPos.right = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), currPos.left, currPos.left && currPos.left.lastId, currPos.right, currPos.right && currPos.right.id, parent, null, new ContentString(newlines));
6702	currPos.right.integrate(transaction, 0);
6703	currPos.forward();
6704	}
6705	insertNegatedAttributes(transaction, parent, currPos, negatedAttributes);
6706	};
6707	var cleanupFormattingGap = (transaction, start, curr, startAttributes, currAttributes) => {
6708	let end = start;
6709	const endFormats = create();
6710	while (end && (!end.countable \|\| end.deleted)) {
6711	if (!end.deleted && end.content.constructor === ContentFormat) {
6712	const cf = (
6713	/** @type {ContentFormat} */
6714	end.content
6715	);
6716	endFormats.set(cf.key, cf);
6717	}
6718	end = end.right;
6719	}
6720	let cleanups = 0;
6721	let reachedCurr = false;
6722	while (start !== end) {
6723	if (curr === start) {
6724	reachedCurr = true;
6725	}
6726	if (!start.deleted) {
6727	const content = start.content;
6728	switch (content.constructor) {
6729	case ContentFormat: {
6730	const { key, value } = (
6731	/** @type {ContentFormat} */
6732	content
6733	);
6734	const startAttrValue = startAttributes.get(key) ?? null;
6735	if (endFormats.get(key) !== content \|\| startAttrValue === value) {
6736	start.delete(transaction);
6737	cleanups++;
6738	if (!reachedCurr && (currAttributes.get(key) ?? null) === value && startAttrValue !== value) {
6739	if (startAttrValue === null) {
6740	currAttributes.delete(key);
6741	} else {
6742	currAttributes.set(key, startAttrValue);
6743	}
6744	}
6745	}
6746	if (!reachedCurr && !start.deleted) {
6747	updateCurrentAttributes(
6748	currAttributes,
6749	/** @type {ContentFormat} */
6750	content
6751	);
6752	}
6753	break;
6754	}
6755	}
6756	}
6757	start = /** @type {Item} */
6758	start.right;
6759	}
6760	return cleanups;
6761	};
6762	var cleanupContextlessFormattingGap = (transaction, item) => {
6763	while (item && item.right && (item.right.deleted \|\| !item.right.countable)) {
6764	item = item.right;
6765	}
6766	const attrs = /* @__PURE__ */ new Set();
6767	while (item && (item.deleted \|\| !item.countable)) {
6768	if (!item.deleted && item.content.constructor === ContentFormat) {
6769	const key = (
6770	/** @type {ContentFormat} */
6771	item.content.key
6772	);
6773	if (attrs.has(key)) {
6774	item.delete(transaction);
6775	} else {
6776	attrs.add(key);
6777	}
6778	}
6779	item = item.left;
6780	}
6781	};
6782	var cleanupYTextFormatting = (type) => {
6783	let res = 0;
6784	transact(
6785	/** @type {Doc} */
6786	type.doc,
6787	(transaction) => {
6788	let start = (
6789	/** @type {Item} */
6790	type._start
6791	);
6792	let end = type._start;
6793	let startAttributes = create();
6794	const currentAttributes = copy(startAttributes);
6795	while (end) {
6796	if (end.deleted === false) {
6797	switch (end.content.constructor) {
6798	case ContentFormat:
6799	updateCurrentAttributes(
6800	currentAttributes,
6801	/** @type {ContentFormat} */
6802	end.content
6803	);
6804	break;
6805	default:
6806	res += cleanupFormattingGap(transaction, start, end, startAttributes, currentAttributes);
6807	startAttributes = copy(currentAttributes);
6808	start = end;
6809	break;
6810	}
6811	}
6812	end = end.right;
6813	}
6814	}
6815	);
6816	return res;
6817	};
6818	var cleanupYTextAfterTransaction = (transaction) => {
6819	const needFullCleanup = /* @__PURE__ */ new Set();
6820	const doc2 = transaction.doc;
6821	for (const [client, afterClock] of transaction.afterState.entries()) {
6822	const clock = transaction.beforeState.get(client) \|\| 0;
6823	if (afterClock === clock) {
6824	continue;
6825	}
6826	iterateStructs(
6827	transaction,
6828	/** @type {Array<Item\|GC>} */
6829	doc2.store.clients.get(client),
6830	clock,
6831	afterClock,
6832	(item) => {
6833	if (!item.deleted && /** @type {Item} */
6834	item.content.constructor === ContentFormat && item.constructor !== GC) {
6835	needFullCleanup.add(
6836	/** @type {any} */
6837	item.parent
6838	);
6839	}
6840	}
6841	);
6842	}
6843	transact(doc2, (t) => {
6844	iterateDeletedStructs(transaction, transaction.deleteSet, (item) => {
6845	if (item instanceof GC \|\| !/** @type {YText} */
6846	item.parent._hasFormatting \|\| needFullCleanup.has(
6847	/** @type {YText} */
6848	item.parent
6849	)) {
6850	return;
6851	}
6852	const parent = (
6853	/** @type {YText} */
6854	item.parent
6855	);
6856	if (item.content.constructor === ContentFormat) {
6857	needFullCleanup.add(parent);
6858	} else {
6859	cleanupContextlessFormattingGap(t, item);
6860	}
6861	});
6862	for (const yText of needFullCleanup) {
6863	cleanupYTextFormatting(yText);
6864	}
6865	});
6866	};
6867	var deleteText = (transaction, currPos, length2) => {
6868	const startLength = length2;
6869	const startAttrs = copy(currPos.currentAttributes);
6870	const start = currPos.right;
6871	while (length2 > 0 && currPos.right !== null) {
6872	if (currPos.right.deleted === false) {
6873	switch (currPos.right.content.constructor) {
6874	case ContentType:
6875	case ContentEmbed:
6876	case ContentString:
6877	if (length2 < currPos.right.length) {
6878	getItemCleanStart(transaction, createID(currPos.right.id.client, currPos.right.id.clock + length2));
6879	}
6880	length2 -= currPos.right.length;
6881	currPos.right.delete(transaction);
6882	break;
6883	}
6884	}
6885	currPos.forward();
6886	}
6887	if (start) {
6888	cleanupFormattingGap(transaction, start, currPos.right, startAttrs, currPos.currentAttributes);
6889	}
6890	const parent = (
6891	/** @type {AbstractType<any>} */
6892	/** @type {Item} */
6893	(currPos.left \|\| currPos.right).parent
6894	);
6895	if (parent._searchMarker) {
6896	updateMarkerChanges(parent._searchMarker, currPos.index, -startLength + length2);
6897	}
6898	return currPos;
6899	};
6900	var YTextEvent = class extends YEvent {
6901	/**
6902	* @param {YText} ytext
6903	* @param {Transaction} transaction
6904	* @param {Set<any>} subs The keys that changed
6905	*/
6906	constructor(ytext, transaction, subs) {
6907	super(ytext, transaction);
6908	this.childListChanged = false;
6909	this.keysChanged = /* @__PURE__ */ new Set();
6910	subs.forEach((sub) => {
6911	if (sub === null) {
6912	this.childListChanged = true;
6913	} else {
6914	this.keysChanged.add(sub);
6915	}
6916	});
6917	}
6918	/**
6919	* @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'\|'update'\|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>\|string, delete?:number, retain?:number}>}}
6920	*/
6921	get changes() {
6922	if (this._changes === null) {
6923	const changes = {
6924	keys: this.keys,
6925	delta: this.delta,
6926	added: /* @__PURE__ */ new Set(),
6927	deleted: /* @__PURE__ */ new Set()
6928	};
6929	this._changes = changes;
6930	}
6931	return (
6932	/** @type {any} */
6933	this._changes
6934	);
6935	}
6936	/**
6937	* Compute the changes in the delta format.
6938	* A {@link https://quilljs.com/docs/delta/\|Quill Delta}) that represents the changes on the document.
6939	*
6940	* @type {Array<{insert?:string\|object\|AbstractType<any>, delete?:number, retain?:number, attributes?: Object<string,any>}>}
6941	*
6942	* @public
6943	*/
6944	get delta() {
6945	if (this._delta === null) {
6946	const y = (
6947	/** @type {Doc} */
6948	this.target.doc
6949	);
6950	const delta = [];
6951	transact(y, (transaction) => {
6952	const currentAttributes = /* @__PURE__ */ new Map();
6953	const oldAttributes = /* @__PURE__ */ new Map();
6954	let item = this.target._start;
6955	let action = null;
6956	const attributes = {};
6957	let insert = "";
6958	let retain = 0;
6959	let deleteLen = 0;
6960	const addOp = () => {
6961	if (action !== null) {
6962	let op = null;
6963	switch (action) {
6964	case "delete":
6965	if (deleteLen > 0) {
6966	op = { delete: deleteLen };
6967	}
6968	deleteLen = 0;
6969	break;
6970	case "insert":
6971	if (typeof insert === "object" \|\| insert.length > 0) {
6972	op = { insert };
6973	if (currentAttributes.size > 0) {
6974	op.attributes = {};
6975	currentAttributes.forEach((value, key) => {
6976	if (value !== null) {
6977	op.attributes[key] = value;
6978	}
6979	});
6980	}
6981	}
6982	insert = "";
6983	break;
6984	case "retain":
6985	if (retain > 0) {
6986	op = { retain };
6987	if (!isEmpty(attributes)) {
6988	op.attributes = assign({}, attributes);
6989	}
6990	}
6991	retain = 0;
6992	break;
6993	}
6994	if (op) delta.push(op);
6995	action = null;
6996	}
6997	};
6998	while (item !== null) {
6999	switch (item.content.constructor) {
7000	case ContentType:
7001	case ContentEmbed:
7002	if (this.adds(item)) {
7003	if (!this.deletes(item)) {
7004	addOp();
7005	action = "insert";
7006	insert = item.content.getContent()[0];
7007	addOp();
7008	}
7009	} else if (this.deletes(item)) {
7010	if (action !== "delete") {
7011	addOp();
7012	action = "delete";
7013	}
7014	deleteLen += 1;
7015	} else if (!item.deleted) {
7016	if (action !== "retain") {
7017	addOp();
7018	action = "retain";
7019	}
7020	retain += 1;
7021	}
7022	break;
7023	case ContentString:
7024	if (this.adds(item)) {
7025	if (!this.deletes(item)) {
7026	if (action !== "insert") {
7027	addOp();
7028	action = "insert";
7029	}
7030	insert += /** @type {ContentString} */
7031	item.content.str;
7032	}
7033	} else if (this.deletes(item)) {
7034	if (action !== "delete") {
7035	addOp();
7036	action = "delete";
7037	}
7038	deleteLen += item.length;
7039	} else if (!item.deleted) {
7040	if (action !== "retain") {
7041	addOp();
7042	action = "retain";
7043	}
7044	retain += item.length;
7045	}
7046	break;
7047	case ContentFormat: {
7048	const { key, value } = (
7049	/** @type {ContentFormat} */
7050	item.content
7051	);
7052	if (this.adds(item)) {
7053	if (!this.deletes(item)) {
7054	const curVal = currentAttributes.get(key) ?? null;
7055	if (!equalAttrs(curVal, value)) {
7056	if (action === "retain") {
7057	addOp();
7058	}
7059	if (equalAttrs(value, oldAttributes.get(key) ?? null)) {
7060	delete attributes[key];
7061	} else {
7062	attributes[key] = value;
7063	}
7064	} else if (value !== null) {
7065	item.delete(transaction);
7066	}
7067	}
7068	} else if (this.deletes(item)) {
7069	oldAttributes.set(key, value);
7070	const curVal = currentAttributes.get(key) ?? null;
7071	if (!equalAttrs(curVal, value)) {
7072	if (action === "retain") {
7073	addOp();
7074	}
7075	attributes[key] = curVal;
7076	}
7077	} else if (!item.deleted) {
7078	oldAttributes.set(key, value);
7079	const attr = attributes[key];
7080	if (attr !== void 0) {
7081	if (!equalAttrs(attr, value)) {
7082	if (action === "retain") {
7083	addOp();
7084	}
7085	if (value === null) {
7086	delete attributes[key];
7087	} else {
7088	attributes[key] = value;
7089	}
7090	} else if (attr !== null) {
7091	item.delete(transaction);
7092	}
7093	}
7094	}
7095	if (!item.deleted) {
7096	if (action === "insert") {
7097	addOp();
7098	}
7099	updateCurrentAttributes(
7100	currentAttributes,
7101	/** @type {ContentFormat} */
7102	item.content
7103	);
7104	}
7105	break;
7106	}
7107	}
7108	item = item.right;
7109	}
7110	addOp();
7111	while (delta.length > 0) {
7112	const lastOp = delta[delta.length - 1];
7113	if (lastOp.retain !== void 0 && lastOp.attributes === void 0) {
7114	delta.pop();
7115	} else {
7116	break;
7117	}
7118	}
7119	});
7120	this._delta = delta;
7121	}
7122	return (
7123	/** @type {any} */
7124	this._delta
7125	);
7126	}
7127	};
7128	var YText = class _YText extends AbstractType {
7129	/**
7130	* @param {String} [string] The initial value of the YText.
7131	*/
7132	constructor(string) {
7133	super();
7134	this._pending = string !== void 0 ? [() => this.insert(0, string)] : [];
7135	this._searchMarker = [];
7136	this._hasFormatting = false;
7137	}
7138	/**
7139	* Number of characters of this text type.
7140	*
7141	* @type {number}
7142	*/
7143	get length() {
7144	this.doc ?? warnPrematureAccess();
7145	return this._length;
7146	}
7147	/**
7148	* @param {Doc} y
7149	* @param {Item} item
7150	*/
7151	_integrate(y, item) {
7152	super._integrate(y, item);
7153	try {
7154	this._pending.forEach((f) => f());
7155	} catch (e) {
7156	console.error(e);
7157	}
7158	this._pending = null;
7159	}
7160	_copy() {
7161	return new _YText();
7162	}
7163	/**
7164	* Makes a copy of this data type that can be included somewhere else.
7165	*
7166	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
7167	*
7168	* @return {YText}
7169	*/
7170	clone() {
7171	const text2 = new _YText();
7172	text2.applyDelta(this.toDelta());
7173	return text2;
7174	}
7175	/**
7176	* Creates YTextEvent and calls observers.
7177	*
7178	* @param {Transaction} transaction
7179	* @param {Set<null\|string>} parentSubs Keys changed on this type. `null` if list was modified.
7180	*/
7181	_callObserver(transaction, parentSubs) {
7182	super._callObserver(transaction, parentSubs);
7183	const event = new YTextEvent(this, transaction, parentSubs);
7184	callTypeObservers(this, transaction, event);
7185	if (!transaction.local && this._hasFormatting) {
7186	transaction._needFormattingCleanup = true;
7187	}
7188	}
7189	/**
7190	* Returns the unformatted string representation of this YText type.
7191	*
7192	* @public
7193	*/
7194	toString() {
7195	this.doc ?? warnPrematureAccess();
7196	let str = "";
7197	let n = this._start;
7198	while (n !== null) {
7199	if (!n.deleted && n.countable && n.content.constructor === ContentString) {
7200	str += /** @type {ContentString} */
7201	n.content.str;
7202	}
7203	n = n.right;
7204	}
7205	return str;
7206	}
7207	/**
7208	* Returns the unformatted string representation of this YText type.
7209	*
7210	* @return {string}
7211	* @public
7212	*/
7213	toJSON() {
7214	return this.toString();
7215	}
7216	/**
7217	* Apply a {@link Delta} on this shared YText type.
7218	*
7219	* @param {Array<any>} delta The changes to apply on this element.
7220	* @param {object} opts
7221	* @param {boolean} [opts.sanitize] Sanitize input delta. Removes ending newlines if set to true.
7222	*
7223	*
7224	* @public
7225	*/
7226	applyDelta(delta, { sanitize = true } = {}) {
7227	if (this.doc !== null) {
7228	transact(this.doc, (transaction) => {
7229	const currPos = new ItemTextListPosition(null, this._start, 0, /* @__PURE__ */ new Map());
7230	for (let i = 0; i < delta.length; i++) {
7231	const op = delta[i];
7232	if (op.insert !== void 0) {
7233	const ins = !sanitize && typeof op.insert === "string" && i === delta.length - 1 && currPos.right === null && op.insert.slice(-1) === "\n" ? op.insert.slice(0, -1) : op.insert;
7234	if (typeof ins !== "string" \|\| ins.length > 0) {
7235	insertText(transaction, this, currPos, ins, op.attributes \|\| {});
7236	}
7237	} else if (op.retain !== void 0) {
7238	formatText(transaction, this, currPos, op.retain, op.attributes \|\| {});
7239	} else if (op.delete !== void 0) {
7240	deleteText(transaction, currPos, op.delete);
7241	}
7242	}
7243	});
7244	} else {
7245	this._pending.push(() => this.applyDelta(delta));
7246	}
7247	}
7248	/**
7249	* Returns the Delta representation of this YText type.
7250	*
7251	* @param {Snapshot} [snapshot]
7252	* @param {Snapshot} [prevSnapshot]
7253	* @param {function('removed' \| 'added', ID):any} [computeYChange]
7254	* @return {any} The Delta representation of this type.
7255	*
7256	* @public
7257	*/
7258	toDelta(snapshot2, prevSnapshot, computeYChange) {
7259	this.doc ?? warnPrematureAccess();
7260	const ops = [];
7261	const currentAttributes = /* @__PURE__ */ new Map();
7262	const doc2 = (
7263	/** @type {Doc} */
7264	this.doc
7265	);
7266	let str = "";
7267	let n = this._start;
7268	function packStr() {
7269	if (str.length > 0) {
7270	const attributes = {};
7271	let addAttributes = false;
7272	currentAttributes.forEach((value, key) => {
7273	addAttributes = true;
7274	attributes[key] = value;
7275	});
7276	const op = { insert: str };
7277	if (addAttributes) {
7278	op.attributes = attributes;
7279	}
7280	ops.push(op);
7281	str = "";
7282	}
7283	}
7284	const computeDelta = () => {
7285	while (n !== null) {
7286	if (isVisible(n, snapshot2) \|\| prevSnapshot !== void 0 && isVisible(n, prevSnapshot)) {
7287	switch (n.content.constructor) {
7288	case ContentString: {
7289	const cur = currentAttributes.get("ychange");
7290	if (snapshot2 !== void 0 && !isVisible(n, snapshot2)) {
7291	if (cur === void 0 \|\| cur.user !== n.id.client \|\| cur.type !== "removed") {
7292	packStr();
7293	currentAttributes.set("ychange", computeYChange ? computeYChange("removed", n.id) : { type: "removed" });
7294	}
7295	} else if (prevSnapshot !== void 0 && !isVisible(n, prevSnapshot)) {
7296	if (cur === void 0 \|\| cur.user !== n.id.client \|\| cur.type !== "added") {
7297	packStr();
7298	currentAttributes.set("ychange", computeYChange ? computeYChange("added", n.id) : { type: "added" });
7299	}
7300	} else if (cur !== void 0) {
7301	packStr();
7302	currentAttributes.delete("ychange");
7303	}
7304	str += /** @type {ContentString} */
7305	n.content.str;
7306	break;
7307	}
7308	case ContentType:
7309	case ContentEmbed: {
7310	packStr();
7311	const op = {
7312	insert: n.content.getContent()[0]
7313	};
7314	if (currentAttributes.size > 0) {
7315	const attrs = (
7316	/** @type {Object<string,any>} */
7317	{}
7318	);
7319	op.attributes = attrs;
7320	currentAttributes.forEach((value, key) => {
7321	attrs[key] = value;
7322	});
7323	}
7324	ops.push(op);
7325	break;
7326	}
7327	case ContentFormat:
7328	if (isVisible(n, snapshot2)) {
7329	packStr();
7330	updateCurrentAttributes(
7331	currentAttributes,
7332	/** @type {ContentFormat} */
7333	n.content
7334	);
7335	}
7336	break;
7337	}
7338	}
7339	n = n.right;
7340	}
7341	packStr();
7342	};
7343	if (snapshot2 \|\| prevSnapshot) {
7344	transact(doc2, (transaction) => {
7345	if (snapshot2) {
7346	splitSnapshotAffectedStructs(transaction, snapshot2);
7347	}
7348	if (prevSnapshot) {
7349	splitSnapshotAffectedStructs(transaction, prevSnapshot);
7350	}
7351	computeDelta();
7352	}, "cleanup");
7353	} else {
7354	computeDelta();
7355	}
7356	return ops;
7357	}
7358	/**
7359	* Insert text at a given index.
7360	*
7361	* @param {number} index The index at which to start inserting.
7362	* @param {String} text The text to insert at the specified position.
7363	* @param {TextAttributes} [attributes] Optionally define some formatting
7364	* information to apply on the inserted
7365	* Text.
7366	* @public
7367	*/
7368	insert(index, text2, attributes) {
7369	if (text2.length <= 0) {
7370	return;
7371	}
7372	const y = this.doc;
7373	if (y !== null) {
7374	transact(y, (transaction) => {
7375	const pos = findPosition(transaction, this, index, !attributes);
7376	if (!attributes) {
7377	attributes = {};
7378	pos.currentAttributes.forEach((v, k) => {
7379	attributes[k] = v;
7380	});
7381	}
7382	insertText(transaction, this, pos, text2, attributes);
7383	});
7384	} else {
7385	this._pending.push(() => this.insert(index, text2, attributes));
7386	}
7387	}
7388	/**
7389	* Inserts an embed at a index.
7390	*
7391	* @param {number} index The index to insert the embed at.
7392	* @param {Object \| AbstractType<any>} embed The Object that represents the embed.
7393	* @param {TextAttributes} [attributes] Attribute information to apply on the
7394	* embed
7395	*
7396	* @public
7397	*/
7398	insertEmbed(index, embed, attributes) {
7399	const y = this.doc;
7400	if (y !== null) {
7401	transact(y, (transaction) => {
7402	const pos = findPosition(transaction, this, index, !attributes);
7403	insertText(transaction, this, pos, embed, attributes \|\| {});
7404	});
7405	} else {
7406	this._pending.push(() => this.insertEmbed(index, embed, attributes \|\| {}));
7407	}
7408	}
7409	/**
7410	* Deletes text starting from an index.
7411	*
7412	* @param {number} index Index at which to start deleting.
7413	* @param {number} length The number of characters to remove. Defaults to 1.
7414	*
7415	* @public
7416	*/
7417	delete(index, length2) {
7418	if (length2 === 0) {
7419	return;
7420	}
7421	const y = this.doc;
7422	if (y !== null) {
7423	transact(y, (transaction) => {
7424	deleteText(transaction, findPosition(transaction, this, index, true), length2);
7425	});
7426	} else {
7427	this._pending.push(() => this.delete(index, length2));
7428	}
7429	}
7430	/**
7431	* Assigns properties to a range of text.
7432	*
7433	* @param {number} index The position where to start formatting.
7434	* @param {number} length The amount of characters to assign properties to.
7435	* @param {TextAttributes} attributes Attribute information to apply on the
7436	* text.
7437	*
7438	* @public
7439	*/
7440	format(index, length2, attributes) {
7441	if (length2 === 0) {
7442	return;
7443	}
7444	const y = this.doc;
7445	if (y !== null) {
7446	transact(y, (transaction) => {
7447	const pos = findPosition(transaction, this, index, false);
7448	if (pos.right === null) {
7449	return;
7450	}
7451	formatText(transaction, this, pos, length2, attributes);
7452	});
7453	} else {
7454	this._pending.push(() => this.format(index, length2, attributes));
7455	}
7456	}
7457	/**
7458	* Removes an attribute.
7459	*
7460	* @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7461	*
7462	* @param {String} attributeName The attribute name that is to be removed.
7463	*
7464	* @public
7465	*/
7466	removeAttribute(attributeName) {
7467	if (this.doc !== null) {
7468	transact(this.doc, (transaction) => {
7469	typeMapDelete(transaction, this, attributeName);
7470	});
7471	} else {
7472	this._pending.push(() => this.removeAttribute(attributeName));
7473	}
7474	}
7475	/**
7476	* Sets or updates an attribute.
7477	*
7478	* @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7479	*
7480	* @param {String} attributeName The attribute name that is to be set.
7481	* @param {any} attributeValue The attribute value that is to be set.
7482	*
7483	* @public
7484	*/
7485	setAttribute(attributeName, attributeValue) {
7486	if (this.doc !== null) {
7487	transact(this.doc, (transaction) => {
7488	typeMapSet(transaction, this, attributeName, attributeValue);
7489	});
7490	} else {
7491	this._pending.push(() => this.setAttribute(attributeName, attributeValue));
7492	}
7493	}
7494	/**
7495	* Returns an attribute value that belongs to the attribute name.
7496	*
7497	* @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7498	*
7499	* @param {String} attributeName The attribute name that identifies the
7500	* queried value.
7501	* @return {any} The queried attribute value.
7502	*
7503	* @public
7504	*/
7505	getAttribute(attributeName) {
7506	return (
7507	/** @type {any} */
7508	typeMapGet(this, attributeName)
7509	);
7510	}
7511	/**
7512	* Returns all attribute name/value pairs in a JSON Object.
7513	*
7514	* @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7515	*
7516	* @return {Object<string, any>} A JSON Object that describes the attributes.
7517	*
7518	* @public
7519	*/
7520	getAttributes() {
7521	return typeMapGetAll(this);
7522	}
7523	/**
7524	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
7525	*/
7526	_write(encoder) {
7527	encoder.writeTypeRef(YTextRefID);
7528	}
7529	};
7530	var readYText = (_decoder) => new YText();
7531	var YXmlTreeWalker = class {
7532	/**
7533	* @param {YXmlFragment \| YXmlElement} root
7534	* @param {function(AbstractType<any>):boolean} [f]
7535	*/
7536	constructor(root, f = () => true) {
7537	this._filter = f;
7538	this._root = root;
7539	this._currentNode = /** @type {Item} */
7540	root._start;
7541	this._firstCall = true;
7542	root.doc ?? warnPrematureAccess();
7543	}
7544	[Symbol.iterator]() {
7545	return this;
7546	}
7547	/**
7548	* Get the next node.
7549	*
7550	* @return {IteratorResult<YXmlElement\|YXmlText\|YXmlHook>} The next node.
7551	*
7552	* @public
7553	*/
7554	next() {
7555	let n = this._currentNode;
7556	let type = n && n.content && /** @type {any} */
7557	n.content.type;
7558	if (n !== null && (!this._firstCall \|\| n.deleted \|\| !this._filter(type))) {
7559	do {
7560	type = /** @type {any} */
7561	n.content.type;
7562	if (!n.deleted && (type.constructor === YXmlElement \|\| type.constructor === YXmlFragment) && type._start !== null) {
7563	n = type._start;
7564	} else {
7565	while (n !== null) {
7566	const nxt = n.next;
7567	if (nxt !== null) {
7568	n = nxt;
7569	break;
7570	} else if (n.parent === this._root) {
7571	n = null;
7572	} else {
7573	n = /** @type {AbstractType<any>} */
7574	n.parent._item;
7575	}
7576	}
7577	}
7578	} while (n !== null && (n.deleted \|\| !this._filter(
7579	/** @type {ContentType} */
7580	n.content.type
7581	)));
7582	}
7583	this._firstCall = false;
7584	if (n === null) {
7585	return { value: void 0, done: true };
7586	}
7587	this._currentNode = n;
7588	return { value: (
7589	/** @type {any} */
7590	n.content.type
7591	), done: false };
7592	}
7593	};
7594	var YXmlFragment = class _YXmlFragment extends AbstractType {
7595	constructor() {
7596	super();
7597	this._prelimContent = [];
7598	}
7599	/**
7600	* @type {YXmlElement\|YXmlText\|null}
7601	*/
7602	get firstChild() {
7603	const first = this._first;
7604	return first ? first.content.getContent()[0] : null;
7605	}
7606	/**
7607	* Integrate this type into the Yjs instance.
7608	*
7609	* * Save this struct in the os
7610	* * This type is sent to other client
7611	* * Observer functions are fired
7612	*
7613	* @param {Doc} y The Yjs instance
7614	* @param {Item} item
7615	*/
7616	_integrate(y, item) {
7617	super._integrate(y, item);
7618	this.insert(
7619	0,
7620	/** @type {Array<any>} */
7621	this._prelimContent
7622	);
7623	this._prelimContent = null;
7624	}
7625	_copy() {
7626	return new _YXmlFragment();
7627	}
7628	/**
7629	* Makes a copy of this data type that can be included somewhere else.
7630	*
7631	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
7632	*
7633	* @return {YXmlFragment}
7634	*/
7635	clone() {
7636	const el = new _YXmlFragment();
7637	el.insert(0, this.toArray().map((item) => item instanceof AbstractType ? item.clone() : item));
7638	return el;
7639	}
7640	get length() {
7641	this.doc ?? warnPrematureAccess();
7642	return this._prelimContent === null ? this._length : this._prelimContent.length;
7643	}
7644	/**
7645	* Create a subtree of childNodes.
7646	*
7647	* @example
7648	* const walker = elem.createTreeWalker(dom => dom.nodeName === 'div')
7649	* for (let node in walker) {
7650	* // `node` is a div node
7651	* nop(node)
7652	* }
7653	*
7654	* @param {function(AbstractType<any>):boolean} filter Function that is called on each child element and
7655	* returns a Boolean indicating whether the child
7656	* is to be included in the subtree.
7657	* @return {YXmlTreeWalker} A subtree and a position within it.
7658	*
7659	* @public
7660	*/
7661	createTreeWalker(filter) {
7662	return new YXmlTreeWalker(this, filter);
7663	}
7664	/**
7665	* Returns the first YXmlElement that matches the query.
7666	* Similar to DOM's {@link querySelector}.
7667	*
7668	* Query support:
7669	* - tagname
7670	* TODO:
7671	* - id
7672	* - attribute
7673	*
7674	* @param {CSS_Selector} query The query on the children.
7675	* @return {YXmlElement\|YXmlText\|YXmlHook\|null} The first element that matches the query or null.
7676	*
7677	* @public
7678	*/
7679	querySelector(query) {
7680	query = query.toUpperCase();
7681	const iterator = new YXmlTreeWalker(this, (element2) => element2.nodeName && element2.nodeName.toUpperCase() === query);
7682	const next = iterator.next();
7683	if (next.done) {
7684	return null;
7685	} else {
7686	return next.value;
7687	}
7688	}
7689	/**
7690	* Returns all YXmlElements that match the query.
7691	* Similar to Dom's {@link querySelectorAll}.
7692	*
7693	* @todo Does not yet support all queries. Currently only query by tagName.
7694	*
7695	* @param {CSS_Selector} query The query on the children
7696	* @return {Array<YXmlElement\|YXmlText\|YXmlHook\|null>} The elements that match this query.
7697	*
7698	* @public
7699	*/
7700	querySelectorAll(query) {
7701	query = query.toUpperCase();
7702	return from(new YXmlTreeWalker(this, (element2) => element2.nodeName && element2.nodeName.toUpperCase() === query));
7703	}
7704	/**
7705	* Creates YXmlEvent and calls observers.
7706	*
7707	* @param {Transaction} transaction
7708	* @param {Set<null\|string>} parentSubs Keys changed on this type. `null` if list was modified.
7709	*/
7710	_callObserver(transaction, parentSubs) {
7711	callTypeObservers(this, transaction, new YXmlEvent(this, parentSubs, transaction));
7712	}
7713	/**
7714	* Get the string representation of all the children of this YXmlFragment.
7715	*
7716	* @return {string} The string representation of all children.
7717	*/
7718	toString() {
7719	return typeListMap(this, (xml) => xml.toString()).join("");
7720	}
7721	/**
7722	* @return {string}
7723	*/
7724	toJSON() {
7725	return this.toString();
7726	}
7727	/**
7728	* Creates a Dom Element that mirrors this YXmlElement.
7729	*
7730	* @param {Document} [_document=document] The document object (you must define
7731	* this when calling this method in
7732	* nodejs)
7733	* @param {Object<string, any>} [hooks={}] Optional property to customize how hooks
7734	* are presented in the DOM
7735	* @param {any} [binding] You should not set this property. This is
7736	* used if DomBinding wants to create a
7737	* association to the created DOM type.
7738	* @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element\|Dom Element}
7739	*
7740	* @public
7741	*/
7742	toDOM(_document = document, hooks = {}, binding) {
7743	const fragment = _document.createDocumentFragment();
7744	if (binding !== void 0) {
7745	binding._createAssociation(fragment, this);
7746	}
7747	typeListForEach(this, (xmlType) => {
7748	fragment.insertBefore(xmlType.toDOM(_document, hooks, binding), null);
7749	});
7750	return fragment;
7751	}
7752	/**
7753	* Inserts new content at an index.
7754	*
7755	* @example
7756	* // Insert character 'a' at position 0
7757	* xml.insert(0, [new Y.XmlText('text')])
7758	*
7759	* @param {number} index The index to insert content at
7760	* @param {Array<YXmlElement\|YXmlText>} content The array of content
7761	*/
7762	insert(index, content) {
7763	if (this.doc !== null) {
7764	transact(this.doc, (transaction) => {
7765	typeListInsertGenerics(transaction, this, index, content);
7766	});
7767	} else {
7768	this._prelimContent.splice(index, 0, ...content);
7769	}
7770	}
7771	/**
7772	* Inserts new content at an index.
7773	*
7774	* @example
7775	* // Insert character 'a' at position 0
7776	* xml.insert(0, [new Y.XmlText('text')])
7777	*
7778	* @param {null\|Item\|YXmlElement\|YXmlText} ref The index to insert content at
7779	* @param {Array<YXmlElement\|YXmlText>} content The array of content
7780	*/
7781	insertAfter(ref, content) {
7782	if (this.doc !== null) {
7783	transact(this.doc, (transaction) => {
7784	const refItem = ref && ref instanceof AbstractType ? ref._item : ref;
7785	typeListInsertGenericsAfter(transaction, this, refItem, content);
7786	});
7787	} else {
7788	const pc = (
7789	/** @type {Array<any>} */
7790	this._prelimContent
7791	);
7792	const index = ref === null ? 0 : pc.findIndex((el) => el === ref) + 1;
7793	if (index === 0 && ref !== null) {
7794	throw create3("Reference item not found");
7795	}
7796	pc.splice(index, 0, ...content);
7797	}
7798	}
7799	/**
7800	* Deletes elements starting from an index.
7801	*
7802	* @param {number} index Index at which to start deleting elements
7803	* @param {number} [length=1] The number of elements to remove. Defaults to 1.
7804	*/
7805	delete(index, length2 = 1) {
7806	if (this.doc !== null) {
7807	transact(this.doc, (transaction) => {
7808	typeListDelete(transaction, this, index, length2);
7809	});
7810	} else {
7811	this._prelimContent.splice(index, length2);
7812	}
7813	}
7814	/**
7815	* Transforms this YArray to a JavaScript Array.
7816	*
7817	* @return {Array<YXmlElement\|YXmlText\|YXmlHook>}
7818	*/
7819	toArray() {
7820	return typeListToArray(this);
7821	}
7822	/**
7823	* Appends content to this YArray.
7824	*
7825	* @param {Array<YXmlElement\|YXmlText>} content Array of content to append.
7826	*/
7827	push(content) {
7828	this.insert(this.length, content);
7829	}
7830	/**
7831	* Prepends content to this YArray.
7832	*
7833	* @param {Array<YXmlElement\|YXmlText>} content Array of content to prepend.
7834	*/
7835	unshift(content) {
7836	this.insert(0, content);
7837	}
7838	/**
7839	* Returns the i-th element from a YArray.
7840	*
7841	* @param {number} index The index of the element to return from the YArray
7842	* @return {YXmlElement\|YXmlText}
7843	*/
7844	get(index) {
7845	return typeListGet(this, index);
7846	}
7847	/**
7848	* Returns a portion of this YXmlFragment into a JavaScript Array selected
7849	* from start to end (end not included).
7850	*
7851	* @param {number} [start]
7852	* @param {number} [end]
7853	* @return {Array<YXmlElement\|YXmlText>}
7854	*/
7855	slice(start = 0, end = this.length) {
7856	return typeListSlice(this, start, end);
7857	}
7858	/**
7859	* Executes a provided function on once on every child element.
7860	*
7861	* @param {function(YXmlElement\|YXmlText,number, typeof self):void} f A function to execute on every element of this YArray.
7862	*/
7863	forEach(f) {
7864	typeListForEach(this, f);
7865	}
7866	/**
7867	* Transform the properties of this type to binary and write it to an
7868	* BinaryEncoder.
7869	*
7870	* This is called when this Item is sent to a remote peer.
7871	*
7872	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder The encoder to write data to.
7873	*/
7874	_write(encoder) {
7875	encoder.writeTypeRef(YXmlFragmentRefID);
7876	}
7877	};
7878	var readYXmlFragment = (_decoder) => new YXmlFragment();
7879	var YXmlElement = class _YXmlElement extends YXmlFragment {
7880	constructor(nodeName = "UNDEFINED") {
7881	super();
7882	this.nodeName = nodeName;
7883	this._prelimAttrs = /* @__PURE__ */ new Map();
7884	}
7885	/**
7886	* @type {YXmlElement\|YXmlText\|null}
7887	*/
7888	get nextSibling() {
7889	const n = this._item ? this._item.next : null;
7890	return n ? (
7891	/** @type {YXmlElement\|YXmlText} */
7892	/** @type {ContentType} */
7893	n.content.type
7894	) : null;
7895	}
7896	/**
7897	* @type {YXmlElement\|YXmlText\|null}
7898	*/
7899	get prevSibling() {
7900	const n = this._item ? this._item.prev : null;
7901	return n ? (
7902	/** @type {YXmlElement\|YXmlText} */
7903	/** @type {ContentType} */
7904	n.content.type
7905	) : null;
7906	}
7907	/**
7908	* Integrate this type into the Yjs instance.
7909	*
7910	* * Save this struct in the os
7911	* * This type is sent to other client
7912	* * Observer functions are fired
7913	*
7914	* @param {Doc} y The Yjs instance
7915	* @param {Item} item
7916	*/
7917	_integrate(y, item) {
7918	super._integrate(y, item);
7919	/** @type {Map<string, any>} */
7920	this._prelimAttrs.forEach((value, key) => {
7921	this.setAttribute(key, value);
7922	});
7923	this._prelimAttrs = null;
7924	}
7925	/**
7926	* Creates an Item with the same effect as this Item (without position effect)
7927	*
7928	* @return {YXmlElement}
7929	*/
7930	_copy() {
7931	return new _YXmlElement(this.nodeName);
7932	}
7933	/**
7934	* Makes a copy of this data type that can be included somewhere else.
7935	*
7936	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
7937	*
7938	* @return {YXmlElement<KV>}
7939	*/
7940	clone() {
7941	const el = new _YXmlElement(this.nodeName);
7942	const attrs = this.getAttributes();
7943	forEach(attrs, (value, key) => {
7944	el.setAttribute(
7945	key,
7946	/** @type {any} */
7947	value
7948	);
7949	});
7950	el.insert(0, this.toArray().map((v) => v instanceof AbstractType ? v.clone() : v));
7951	return el;
7952	}
7953	/**
7954	* Returns the XML serialization of this YXmlElement.
7955	* The attributes are ordered by attribute-name, so you can easily use this
7956	* method to compare YXmlElements
7957	*
7958	* @return {string} The string representation of this type.
7959	*
7960	* @public
7961	*/
7962	toString() {
7963	const attrs = this.getAttributes();
7964	const stringBuilder = [];
7965	const keys2 = [];
7966	for (const key in attrs) {
7967	keys2.push(key);
7968	}
7969	keys2.sort();
7970	const keysLen = keys2.length;
7971	for (let i = 0; i < keysLen; i++) {
7972	const key = keys2[i];
7973	stringBuilder.push(key + '="' + attrs[key] + '"');
7974	}
7975	const nodeName = this.nodeName.toLocaleLowerCase();
7976	const attrsString = stringBuilder.length > 0 ? " " + stringBuilder.join(" ") : "";
7977	return `<${nodeName}${attrsString}>${super.toString()}</${nodeName}>`;
7978	}
7979	/**
7980	* Removes an attribute from this YXmlElement.
7981	*
7982	* @param {string} attributeName The attribute name that is to be removed.
7983	*
7984	* @public
7985	*/
7986	removeAttribute(attributeName) {
7987	if (this.doc !== null) {
7988	transact(this.doc, (transaction) => {
7989	typeMapDelete(transaction, this, attributeName);
7990	});
7991	} else {
7992	this._prelimAttrs.delete(attributeName);
7993	}
7994	}
7995	/**
7996	* Sets or updates an attribute.
7997	*
7998	* @template {keyof KV & string} KEY
7999	*
8000	* @param {KEY} attributeName The attribute name that is to be set.
8001	* @param {KV[KEY]} attributeValue The attribute value that is to be set.
8002	*
8003	* @public
8004	*/
8005	setAttribute(attributeName, attributeValue) {
8006	if (this.doc !== null) {
8007	transact(this.doc, (transaction) => {
8008	typeMapSet(transaction, this, attributeName, attributeValue);
8009	});
8010	} else {
8011	this._prelimAttrs.set(attributeName, attributeValue);
8012	}
8013	}
8014	/**
8015	* Returns an attribute value that belongs to the attribute name.
8016	*
8017	* @template {keyof KV & string} KEY
8018	*
8019	* @param {KEY} attributeName The attribute name that identifies the
8020	* queried value.
8021	* @return {KV[KEY]\|undefined} The queried attribute value.
8022	*
8023	* @public
8024	*/
8025	getAttribute(attributeName) {
8026	return (
8027	/** @type {any} */
8028	typeMapGet(this, attributeName)
8029	);
8030	}
8031	/**
8032	* Returns whether an attribute exists
8033	*
8034	* @param {string} attributeName The attribute name to check for existence.
8035	* @return {boolean} whether the attribute exists.
8036	*
8037	* @public
8038	*/
8039	hasAttribute(attributeName) {
8040	return (
8041	/** @type {any} */
8042	typeMapHas(this, attributeName)
8043	);
8044	}
8045	/**
8046	* Returns all attribute name/value pairs in a JSON Object.
8047	*
8048	* @param {Snapshot} [snapshot]
8049	* @return {{ [Key in Extract<keyof KV,string>]?: KV[Key]}} A JSON Object that describes the attributes.
8050	*
8051	* @public
8052	*/
8053	getAttributes(snapshot2) {
8054	return (
8055	/** @type {any} */
8056	snapshot2 ? typeMapGetAllSnapshot(this, snapshot2) : typeMapGetAll(this)
8057	);
8058	}
8059	/**
8060	* Creates a Dom Element that mirrors this YXmlElement.
8061	*
8062	* @param {Document} [_document=document] The document object (you must define
8063	* this when calling this method in
8064	* nodejs)
8065	* @param {Object<string, any>} [hooks={}] Optional property to customize how hooks
8066	* are presented in the DOM
8067	* @param {any} [binding] You should not set this property. This is
8068	* used if DomBinding wants to create a
8069	* association to the created DOM type.
8070	* @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element\|Dom Element}
8071	*
8072	* @public
8073	*/
8074	toDOM(_document = document, hooks = {}, binding) {
8075	const dom = _document.createElement(this.nodeName);
8076	const attrs = this.getAttributes();
8077	for (const key in attrs) {
8078	const value = attrs[key];
8079	if (typeof value === "string") {
8080	dom.setAttribute(key, value);
8081	}
8082	}
8083	typeListForEach(this, (yxml) => {
8084	dom.appendChild(yxml.toDOM(_document, hooks, binding));
8085	});
8086	if (binding !== void 0) {
8087	binding._createAssociation(dom, this);
8088	}
8089	return dom;
8090	}
8091	/**
8092	* Transform the properties of this type to binary and write it to an
8093	* BinaryEncoder.
8094	*
8095	* This is called when this Item is sent to a remote peer.
8096	*
8097	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder The encoder to write data to.
8098	*/
8099	_write(encoder) {
8100	encoder.writeTypeRef(YXmlElementRefID);
8101	encoder.writeKey(this.nodeName);
8102	}
8103	};
8104	var readYXmlElement = (decoder) => new YXmlElement(decoder.readKey());
8105	var YXmlEvent = class extends YEvent {
8106	/**
8107	* @param {YXmlElement\|YXmlText\|YXmlFragment} target The target on which the event is created.
8108	* @param {Set<string\|null>} subs The set of changed attributes. `null` is included if the
8109	* child list changed.
8110	* @param {Transaction} transaction The transaction instance with which the
8111	* change was created.
8112	*/
8113	constructor(target, subs, transaction) {
8114	super(target, transaction);
8115	this.childListChanged = false;
8116	this.attributesChanged = /* @__PURE__ */ new Set();
8117	subs.forEach((sub) => {
8118	if (sub === null) {
8119	this.childListChanged = true;
8120	} else {
8121	this.attributesChanged.add(sub);
8122	}
8123	});
8124	}
8125	};
8126	var YXmlHook = class _YXmlHook extends YMap {
8127	/**
8128	* @param {string} hookName nodeName of the Dom Node.
8129	*/
8130	constructor(hookName) {
8131	super();
8132	this.hookName = hookName;
8133	}
8134	/**
8135	* Creates an Item with the same effect as this Item (without position effect)
8136	*/
8137	_copy() {
8138	return new _YXmlHook(this.hookName);
8139	}
8140	/**
8141	* Makes a copy of this data type that can be included somewhere else.
8142	*
8143	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
8144	*
8145	* @return {YXmlHook}
8146	*/
8147	clone() {
8148	const el = new _YXmlHook(this.hookName);
8149	this.forEach((value, key) => {
8150	el.set(key, value);
8151	});
8152	return el;
8153	}
8154	/**
8155	* Creates a Dom Element that mirrors this YXmlElement.
8156	*
8157	* @param {Document} [_document=document] The document object (you must define
8158	* this when calling this method in
8159	* nodejs)
8160	* @param {Object.<string, any>} [hooks] Optional property to customize how hooks
8161	* are presented in the DOM
8162	* @param {any} [binding] You should not set this property. This is
8163	* used if DomBinding wants to create a
8164	* association to the created DOM type
8165	* @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element\|Dom Element}
8166	*
8167	* @public
8168	*/
8169	toDOM(_document = document, hooks = {}, binding) {
8170	const hook = hooks[this.hookName];
8171	let dom;
8172	if (hook !== void 0) {
8173	dom = hook.createDom(this);
8174	} else {
8175	dom = document.createElement(this.hookName);
8176	}
8177	dom.setAttribute("data-yjs-hook", this.hookName);
8178	if (binding !== void 0) {
8179	binding._createAssociation(dom, this);
8180	}
8181	return dom;
8182	}
8183	/**
8184	* Transform the properties of this type to binary and write it to an
8185	* BinaryEncoder.
8186	*
8187	* This is called when this Item is sent to a remote peer.
8188	*
8189	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder The encoder to write data to.
8190	*/
8191	_write(encoder) {
8192	encoder.writeTypeRef(YXmlHookRefID);
8193	encoder.writeKey(this.hookName);
8194	}
8195	};
8196	var readYXmlHook = (decoder) => new YXmlHook(decoder.readKey());
8197	var YXmlText = class _YXmlText extends YText {
8198	/**
8199	* @type {YXmlElement\|YXmlText\|null}
8200	*/
8201	get nextSibling() {
8202	const n = this._item ? this._item.next : null;
8203	return n ? (
8204	/** @type {YXmlElement\|YXmlText} */
8205	/** @type {ContentType} */
8206	n.content.type
8207	) : null;
8208	}
8209	/**
8210	* @type {YXmlElement\|YXmlText\|null}
8211	*/
8212	get prevSibling() {
8213	const n = this._item ? this._item.prev : null;
8214	return n ? (
8215	/** @type {YXmlElement\|YXmlText} */
8216	/** @type {ContentType} */
8217	n.content.type
8218	) : null;
8219	}
8220	_copy() {
8221	return new _YXmlText();
8222	}
8223	/**
8224	* Makes a copy of this data type that can be included somewhere else.
8225	*
8226	* Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
8227	*
8228	* @return {YXmlText}
8229	*/
8230	clone() {
8231	const text2 = new _YXmlText();
8232	text2.applyDelta(this.toDelta());
8233	return text2;
8234	}
8235	/**
8236	* Creates a Dom Element that mirrors this YXmlText.
8237	*
8238	* @param {Document} [_document=document] The document object (you must define
8239	* this when calling this method in
8240	* nodejs)
8241	* @param {Object<string, any>} [hooks] Optional property to customize how hooks
8242	* are presented in the DOM
8243	* @param {any} [binding] You should not set this property. This is
8244	* used if DomBinding wants to create a
8245	* association to the created DOM type.
8246	* @return {Text} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element\|Dom Element}
8247	*
8248	* @public
8249	*/
8250	toDOM(_document = document, hooks, binding) {
8251	const dom = _document.createTextNode(this.toString());
8252	if (binding !== void 0) {
8253	binding._createAssociation(dom, this);
8254	}
8255	return dom;
8256	}
8257	toString() {
8258	return this.toDelta().map((delta) => {
8259	const nestedNodes = [];
8260	for (const nodeName in delta.attributes) {
8261	const attrs = [];
8262	for (const key in delta.attributes[nodeName]) {
8263	attrs.push({ key, value: delta.attributes[nodeName][key] });
8264	}
8265	attrs.sort((a, b) => a.key < b.key ? -1 : 1);
8266	nestedNodes.push({ nodeName, attrs });
8267	}
8268	nestedNodes.sort((a, b) => a.nodeName < b.nodeName ? -1 : 1);
8269	let str = "";
8270	for (let i = 0; i < nestedNodes.length; i++) {
8271	const node = nestedNodes[i];
8272	str += `<${node.nodeName}`;
8273	for (let j = 0; j < node.attrs.length; j++) {
8274	const attr = node.attrs[j];
8275	str += ` ${attr.key}="${attr.value}"`;
8276	}
8277	str += ">";
8278	}
8279	str += delta.insert;
8280	for (let i = nestedNodes.length - 1; i >= 0; i--) {
8281	str += `</${nestedNodes[i].nodeName}>`;
8282	}
8283	return str;
8284	}).join("");
8285	}
8286	/**
8287	* @return {string}
8288	*/
8289	toJSON() {
8290	return this.toString();
8291	}
8292	/**
8293	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8294	*/
8295	_write(encoder) {
8296	encoder.writeTypeRef(YXmlTextRefID);
8297	}
8298	};
8299	var readYXmlText = (decoder) => new YXmlText();
8300	var AbstractStruct = class {
8301	/**
8302	* @param {ID} id
8303	* @param {number} length
8304	*/
8305	constructor(id2, length2) {
8306	this.id = id2;
8307	this.length = length2;
8308	}
8309	/**
8310	* @type {boolean}
8311	*/
8312	get deleted() {
8313	throw methodUnimplemented();
8314	}
8315	/**
8316	* Merge this struct with the item to the right.
8317	* This method is already assuming that `this.id.clock + this.length === this.id.clock`.
8318	* Also this method does not remove right from StructStore!
8319	* @param {AbstractStruct} right
8320	* @return {boolean} whether this merged with right
8321	*/
8322	mergeWith(right) {
8323	return false;
8324	}
8325	/**
8326	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder The encoder to write data to.
8327	* @param {number} offset
8328	* @param {number} encodingRef
8329	*/
8330	write(encoder, offset, encodingRef) {
8331	throw methodUnimplemented();
8332	}
8333	/**
8334	* @param {Transaction} transaction
8335	* @param {number} offset
8336	*/
8337	integrate(transaction, offset) {
8338	throw methodUnimplemented();
8339	}
8340	};
8341	var structGCRefNumber = 0;
8342	var GC = class extends AbstractStruct {
8343	get deleted() {
8344	return true;
8345	}
8346	delete() {
8347	}
8348	/**
8349	* @param {GC} right
8350	* @return {boolean}
8351	*/
8352	mergeWith(right) {
8353	if (this.constructor !== right.constructor) {
8354	return false;
8355	}
8356	this.length += right.length;
8357	return true;
8358	}
8359	/**
8360	* @param {Transaction} transaction
8361	* @param {number} offset
8362	*/
8363	integrate(transaction, offset) {
8364	if (offset > 0) {
8365	this.id.clock += offset;
8366	this.length -= offset;
8367	}
8368	addStruct(transaction.doc.store, this);
8369	}
8370	/**
8371	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8372	* @param {number} offset
8373	*/
8374	write(encoder, offset) {
8375	encoder.writeInfo(structGCRefNumber);
8376	encoder.writeLen(this.length - offset);
8377	}
8378	/**
8379	* @param {Transaction} transaction
8380	* @param {StructStore} store
8381	* @return {null \| number}
8382	*/
8383	getMissing(transaction, store) {
8384	return null;
8385	}
8386	};
8387	var ContentBinary = class _ContentBinary {
8388	/**
8389	* @param {Uint8Array} content
8390	*/
8391	constructor(content) {
8392	this.content = content;
8393	}
8394	/**
8395	* @return {number}
8396	*/
8397	getLength() {
8398	return 1;
8399	}
8400	/**
8401	* @return {Array<any>}
8402	*/
8403	getContent() {
8404	return [this.content];
8405	}
8406	/**
8407	* @return {boolean}
8408	*/
8409	isCountable() {
8410	return true;
8411	}
8412	/**
8413	* @return {ContentBinary}
8414	*/
8415	copy() {
8416	return new _ContentBinary(this.content);
8417	}
8418	/**
8419	* @param {number} offset
8420	* @return {ContentBinary}
8421	*/
8422	splice(offset) {
8423	throw methodUnimplemented();
8424	}
8425	/**
8426	* @param {ContentBinary} right
8427	* @return {boolean}
8428	*/
8429	mergeWith(right) {
8430	return false;
8431	}
8432	/**
8433	* @param {Transaction} transaction
8434	* @param {Item} item
8435	*/
8436	integrate(transaction, item) {
8437	}
8438	/**
8439	* @param {Transaction} transaction
8440	*/
8441	delete(transaction) {
8442	}
8443	/**
8444	* @param {StructStore} store
8445	*/
8446	gc(store) {
8447	}
8448	/**
8449	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8450	* @param {number} offset
8451	*/
8452	write(encoder, offset) {
8453	encoder.writeBuf(this.content);
8454	}
8455	/**
8456	* @return {number}
8457	*/
8458	getRef() {
8459	return 3;
8460	}
8461	};
8462	var readContentBinary = (decoder) => new ContentBinary(decoder.readBuf());
8463	var ContentDeleted = class _ContentDeleted {
8464	/**
8465	* @param {number} len
8466	*/
8467	constructor(len) {
8468	this.len = len;
8469	}
8470	/**
8471	* @return {number}
8472	*/
8473	getLength() {
8474	return this.len;
8475	}
8476	/**
8477	* @return {Array<any>}
8478	*/
8479	getContent() {
8480	return [];
8481	}
8482	/**
8483	* @return {boolean}
8484	*/
8485	isCountable() {
8486	return false;
8487	}
8488	/**
8489	* @return {ContentDeleted}
8490	*/
8491	copy() {
8492	return new _ContentDeleted(this.len);
8493	}
8494	/**
8495	* @param {number} offset
8496	* @return {ContentDeleted}
8497	*/
8498	splice(offset) {
8499	const right = new _ContentDeleted(this.len - offset);
8500	this.len = offset;
8501	return right;
8502	}
8503	/**
8504	* @param {ContentDeleted} right
8505	* @return {boolean}
8506	*/
8507	mergeWith(right) {
8508	this.len += right.len;
8509	return true;
8510	}
8511	/**
8512	* @param {Transaction} transaction
8513	* @param {Item} item
8514	*/
8515	integrate(transaction, item) {
8516	addToDeleteSet(transaction.deleteSet, item.id.client, item.id.clock, this.len);
8517	item.markDeleted();
8518	}
8519	/**
8520	* @param {Transaction} transaction
8521	*/
8522	delete(transaction) {
8523	}
8524	/**
8525	* @param {StructStore} store
8526	*/
8527	gc(store) {
8528	}
8529	/**
8530	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8531	* @param {number} offset
8532	*/
8533	write(encoder, offset) {
8534	encoder.writeLen(this.len - offset);
8535	}
8536	/**
8537	* @return {number}
8538	*/
8539	getRef() {
8540	return 1;
8541	}
8542	};
8543	var readContentDeleted = (decoder) => new ContentDeleted(decoder.readLen());
8544	var createDocFromOpts = (guid, opts) => new Doc({ guid, ...opts, shouldLoad: opts.shouldLoad \|\| opts.autoLoad \|\| false });
8545	var ContentDoc = class _ContentDoc {
8546	/**
8547	* @param {Doc} doc
8548	*/
8549	constructor(doc2) {
8550	if (doc2._item) {
8551	console.error("This document was already integrated as a sub-document. You should create a second instance instead with the same guid.");
8552	}
8553	this.doc = doc2;
8554	const opts = {};
8555	this.opts = opts;
8556	if (!doc2.gc) {
8557	opts.gc = false;
8558	}
8559	if (doc2.autoLoad) {
8560	opts.autoLoad = true;
8561	}
8562	if (doc2.meta !== null) {
8563	opts.meta = doc2.meta;
8564	}
8565	}
8566	/**
8567	* @return {number}
8568	*/
8569	getLength() {
8570	return 1;
8571	}
8572	/**
8573	* @return {Array<any>}
8574	*/
8575	getContent() {
8576	return [this.doc];
8577	}
8578	/**
8579	* @return {boolean}
8580	*/
8581	isCountable() {
8582	return true;
8583	}
8584	/**
8585	* @return {ContentDoc}
8586	*/
8587	copy() {
8588	return new _ContentDoc(createDocFromOpts(this.doc.guid, this.opts));
8589	}
8590	/**
8591	* @param {number} offset
8592	* @return {ContentDoc}
8593	*/
8594	splice(offset) {
8595	throw methodUnimplemented();
8596	}
8597	/**
8598	* @param {ContentDoc} right
8599	* @return {boolean}
8600	*/
8601	mergeWith(right) {
8602	return false;
8603	}
8604	/**
8605	* @param {Transaction} transaction
8606	* @param {Item} item
8607	*/
8608	integrate(transaction, item) {
8609	this.doc._item = item;
8610	transaction.subdocsAdded.add(this.doc);
8611	if (this.doc.shouldLoad) {
8612	transaction.subdocsLoaded.add(this.doc);
8613	}
8614	}
8615	/**
8616	* @param {Transaction} transaction
8617	*/
8618	delete(transaction) {
8619	if (transaction.subdocsAdded.has(this.doc)) {
8620	transaction.subdocsAdded.delete(this.doc);
8621	} else {
8622	transaction.subdocsRemoved.add(this.doc);
8623	}
8624	}
8625	/**
8626	* @param {StructStore} store
8627	*/
8628	gc(store) {
8629	}
8630	/**
8631	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8632	* @param {number} offset
8633	*/
8634	write(encoder, offset) {
8635	encoder.writeString(this.doc.guid);
8636	encoder.writeAny(this.opts);
8637	}
8638	/**
8639	* @return {number}
8640	*/
8641	getRef() {
8642	return 9;
8643	}
8644	};
8645	var readContentDoc = (decoder) => new ContentDoc(createDocFromOpts(decoder.readString(), decoder.readAny()));
8646	var ContentEmbed = class _ContentEmbed {
8647	/**
8648	* @param {Object} embed
8649	*/
8650	constructor(embed) {
8651	this.embed = embed;
8652	}
8653	/**
8654	* @return {number}
8655	*/
8656	getLength() {
8657	return 1;
8658	}
8659	/**
8660	* @return {Array<any>}
8661	*/
8662	getContent() {
8663	return [this.embed];
8664	}
8665	/**
8666	* @return {boolean}
8667	*/
8668	isCountable() {
8669	return true;
8670	}
8671	/**
8672	* @return {ContentEmbed}
8673	*/
8674	copy() {
8675	return new _ContentEmbed(this.embed);
8676	}
8677	/**
8678	* @param {number} offset
8679	* @return {ContentEmbed}
8680	*/
8681	splice(offset) {
8682	throw methodUnimplemented();
8683	}
8684	/**
8685	* @param {ContentEmbed} right
8686	* @return {boolean}
8687	*/
8688	mergeWith(right) {
8689	return false;
8690	}
8691	/**
8692	* @param {Transaction} transaction
8693	* @param {Item} item
8694	*/
8695	integrate(transaction, item) {
8696	}
8697	/**
8698	* @param {Transaction} transaction
8699	*/
8700	delete(transaction) {
8701	}
8702	/**
8703	* @param {StructStore} store
8704	*/
8705	gc(store) {
8706	}
8707	/**
8708	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8709	* @param {number} offset
8710	*/
8711	write(encoder, offset) {
8712	encoder.writeJSON(this.embed);
8713	}
8714	/**
8715	* @return {number}
8716	*/
8717	getRef() {
8718	return 5;
8719	}
8720	};
8721	var readContentEmbed = (decoder) => new ContentEmbed(decoder.readJSON());
8722	var ContentFormat = class _ContentFormat {
8723	/**
8724	* @param {string} key
8725	* @param {Object} value
8726	*/
8727	constructor(key, value) {
8728	this.key = key;
8729	this.value = value;
8730	}
8731	/**
8732	* @return {number}
8733	*/
8734	getLength() {
8735	return 1;
8736	}
8737	/**
8738	* @return {Array<any>}
8739	*/
8740	getContent() {
8741	return [];
8742	}
8743	/**
8744	* @return {boolean}
8745	*/
8746	isCountable() {
8747	return false;
8748	}
8749	/**
8750	* @return {ContentFormat}
8751	*/
8752	copy() {
8753	return new _ContentFormat(this.key, this.value);
8754	}
8755	/**
8756	* @param {number} _offset
8757	* @return {ContentFormat}
8758	*/
8759	splice(_offset) {
8760	throw methodUnimplemented();
8761	}
8762	/**
8763	* @param {ContentFormat} _right
8764	* @return {boolean}
8765	*/
8766	mergeWith(_right) {
8767	return false;
8768	}
8769	/**
8770	* @param {Transaction} _transaction
8771	* @param {Item} item
8772	*/
8773	integrate(_transaction, item) {
8774	const p = (
8775	/** @type {YText} */
8776	item.parent
8777	);
8778	p._searchMarker = null;
8779	p._hasFormatting = true;
8780	}
8781	/**
8782	* @param {Transaction} transaction
8783	*/
8784	delete(transaction) {
8785	}
8786	/**
8787	* @param {StructStore} store
8788	*/
8789	gc(store) {
8790	}
8791	/**
8792	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8793	* @param {number} offset
8794	*/
8795	write(encoder, offset) {
8796	encoder.writeKey(this.key);
8797	encoder.writeJSON(this.value);
8798	}
8799	/**
8800	* @return {number}
8801	*/
8802	getRef() {
8803	return 6;
8804	}
8805	};
8806	var readContentFormat = (decoder) => new ContentFormat(decoder.readKey(), decoder.readJSON());
8807	var ContentJSON = class _ContentJSON {
8808	/**
8809	* @param {Array<any>} arr
8810	*/
8811	constructor(arr) {
8812	this.arr = arr;
8813	}
8814	/**
8815	* @return {number}
8816	*/
8817	getLength() {
8818	return this.arr.length;
8819	}
8820	/**
8821	* @return {Array<any>}
8822	*/
8823	getContent() {
8824	return this.arr;
8825	}
8826	/**
8827	* @return {boolean}
8828	*/
8829	isCountable() {
8830	return true;
8831	}
8832	/**
8833	* @return {ContentJSON}
8834	*/
8835	copy() {
8836	return new _ContentJSON(this.arr);
8837	}
8838	/**
8839	* @param {number} offset
8840	* @return {ContentJSON}
8841	*/
8842	splice(offset) {
8843	const right = new _ContentJSON(this.arr.slice(offset));
8844	this.arr = this.arr.slice(0, offset);
8845	return right;
8846	}
8847	/**
8848	* @param {ContentJSON} right
8849	* @return {boolean}
8850	*/
8851	mergeWith(right) {
8852	this.arr = this.arr.concat(right.arr);
8853	return true;
8854	}
8855	/**
8856	* @param {Transaction} transaction
8857	* @param {Item} item
8858	*/
8859	integrate(transaction, item) {
8860	}
8861	/**
8862	* @param {Transaction} transaction
8863	*/
8864	delete(transaction) {
8865	}
8866	/**
8867	* @param {StructStore} store
8868	*/
8869	gc(store) {
8870	}
8871	/**
8872	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8873	* @param {number} offset
8874	*/
8875	write(encoder, offset) {
8876	const len = this.arr.length;
8877	encoder.writeLen(len - offset);
8878	for (let i = offset; i < len; i++) {
8879	const c = this.arr[i];
8880	encoder.writeString(c === void 0 ? "undefined" : JSON.stringify(c));
8881	}
8882	}
8883	/**
8884	* @return {number}
8885	*/
8886	getRef() {
8887	return 2;
8888	}
8889	};
8890	var readContentJSON = (decoder) => {
8891	const len = decoder.readLen();
8892	const cs = [];
8893	for (let i = 0; i < len; i++) {
8894	const c = decoder.readString();
8895	if (c === "undefined") {
8896	cs.push(void 0);
8897	} else {
8898	cs.push(JSON.parse(c));
8899	}
8900	}
8901	return new ContentJSON(cs);
8902	};
8903	var isDevMode = getVariable("node_env") === "development";
8904	var ContentAny = class _ContentAny {
8905	/**
8906	* @param {Array<any>} arr
8907	*/
8908	constructor(arr) {
8909	this.arr = arr;
8910	isDevMode && deepFreeze(arr);
8911	}
8912	/**
8913	* @return {number}
8914	*/
8915	getLength() {
8916	return this.arr.length;
8917	}
8918	/**
8919	* @return {Array<any>}
8920	*/
8921	getContent() {
8922	return this.arr;
8923	}
8924	/**
8925	* @return {boolean}
8926	*/
8927	isCountable() {
8928	return true;
8929	}
8930	/**
8931	* @return {ContentAny}
8932	*/
8933	copy() {
8934	return new _ContentAny(this.arr);
8935	}
8936	/**
8937	* @param {number} offset
8938	* @return {ContentAny}
8939	*/
8940	splice(offset) {
8941	const right = new _ContentAny(this.arr.slice(offset));
8942	this.arr = this.arr.slice(0, offset);
8943	return right;
8944	}
8945	/**
8946	* @param {ContentAny} right
8947	* @return {boolean}
8948	*/
8949	mergeWith(right) {
8950	this.arr = this.arr.concat(right.arr);
8951	return true;
8952	}
8953	/**
8954	* @param {Transaction} transaction
8955	* @param {Item} item
8956	*/
8957	integrate(transaction, item) {
8958	}
8959	/**
8960	* @param {Transaction} transaction
8961	*/
8962	delete(transaction) {
8963	}
8964	/**
8965	* @param {StructStore} store
8966	*/
8967	gc(store) {
8968	}
8969	/**
8970	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
8971	* @param {number} offset
8972	*/
8973	write(encoder, offset) {
8974	const len = this.arr.length;
8975	encoder.writeLen(len - offset);
8976	for (let i = offset; i < len; i++) {
8977	const c = this.arr[i];
8978	encoder.writeAny(c);
8979	}
8980	}
8981	/**
8982	* @return {number}
8983	*/
8984	getRef() {
8985	return 8;
8986	}
8987	};
8988	var readContentAny = (decoder) => {
8989	const len = decoder.readLen();
8990	const cs = [];
8991	for (let i = 0; i < len; i++) {
8992	cs.push(decoder.readAny());
8993	}
8994	return new ContentAny(cs);
8995	};
8996	var ContentString = class _ContentString {
8997	/**
8998	* @param {string} str
8999	*/
9000	constructor(str) {
9001	this.str = str;
9002	}
9003	/**
9004	* @return {number}
9005	*/
9006	getLength() {
9007	return this.str.length;
9008	}
9009	/**
9010	* @return {Array<any>}
9011	*/
9012	getContent() {
9013	return this.str.split("");
9014	}
9015	/**
9016	* @return {boolean}
9017	*/
9018	isCountable() {
9019	return true;
9020	}
9021	/**
9022	* @return {ContentString}
9023	*/
9024	copy() {
9025	return new _ContentString(this.str);
9026	}
9027	/**
9028	* @param {number} offset
9029	* @return {ContentString}
9030	*/
9031	splice(offset) {
9032	const right = new _ContentString(this.str.slice(offset));
9033	this.str = this.str.slice(0, offset);
9034	const firstCharCode = this.str.charCodeAt(offset - 1);
9035	if (firstCharCode >= 55296 && firstCharCode <= 56319) {
9036	this.str = this.str.slice(0, offset - 1) + "\uFFFD";
9037	right.str = "\uFFFD" + right.str.slice(1);
9038	}
9039	return right;
9040	}
9041	/**
9042	* @param {ContentString} right
9043	* @return {boolean}
9044	*/
9045	mergeWith(right) {
9046	this.str += right.str;
9047	return true;
9048	}
9049	/**
9050	* @param {Transaction} transaction
9051	* @param {Item} item
9052	*/
9053	integrate(transaction, item) {
9054	}
9055	/**
9056	* @param {Transaction} transaction
9057	*/
9058	delete(transaction) {
9059	}
9060	/**
9061	* @param {StructStore} store
9062	*/
9063	gc(store) {
9064	}
9065	/**
9066	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
9067	* @param {number} offset
9068	*/
9069	write(encoder, offset) {
9070	encoder.writeString(offset === 0 ? this.str : this.str.slice(offset));
9071	}
9072	/**
9073	* @return {number}
9074	*/
9075	getRef() {
9076	return 4;
9077	}
9078	};
9079	var readContentString = (decoder) => new ContentString(decoder.readString());
9080	var typeRefs = [
9081	readYArray,
9082	readYMap,
9083	readYText,
9084	readYXmlElement,
9085	readYXmlFragment,
9086	readYXmlHook,
9087	readYXmlText
9088	];
9089	var YArrayRefID = 0;
9090	var YMapRefID = 1;
9091	var YTextRefID = 2;
9092	var YXmlElementRefID = 3;
9093	var YXmlFragmentRefID = 4;
9094	var YXmlHookRefID = 5;
9095	var YXmlTextRefID = 6;
9096	var ContentType = class _ContentType {
9097	/**
9098	* @param {AbstractType<any>} type
9099	*/
9100	constructor(type) {
9101	this.type = type;
9102	}
9103	/**
9104	* @return {number}
9105	*/
9106	getLength() {
9107	return 1;
9108	}
9109	/**
9110	* @return {Array<any>}
9111	*/
9112	getContent() {
9113	return [this.type];
9114	}
9115	/**
9116	* @return {boolean}
9117	*/
9118	isCountable() {
9119	return true;
9120	}
9121	/**
9122	* @return {ContentType}
9123	*/
9124	copy() {
9125	return new _ContentType(this.type._copy());
9126	}
9127	/**
9128	* @param {number} offset
9129	* @return {ContentType}
9130	*/
9131	splice(offset) {
9132	throw methodUnimplemented();
9133	}
9134	/**
9135	* @param {ContentType} right
9136	* @return {boolean}
9137	*/
9138	mergeWith(right) {
9139	return false;
9140	}
9141	/**
9142	* @param {Transaction} transaction
9143	* @param {Item} item
9144	*/
9145	integrate(transaction, item) {
9146	this.type._integrate(transaction.doc, item);
9147	}
9148	/**
9149	* @param {Transaction} transaction
9150	*/
9151	delete(transaction) {
9152	let item = this.type._start;
9153	while (item !== null) {
9154	if (!item.deleted) {
9155	item.delete(transaction);
9156	} else if (item.id.clock < (transaction.beforeState.get(item.id.client) \|\| 0)) {
9157	transaction._mergeStructs.push(item);
9158	}
9159	item = item.right;
9160	}
9161	this.type._map.forEach((item2) => {
9162	if (!item2.deleted) {
9163	item2.delete(transaction);
9164	} else if (item2.id.clock < (transaction.beforeState.get(item2.id.client) \|\| 0)) {
9165	transaction._mergeStructs.push(item2);
9166	}
9167	});
9168	transaction.changed.delete(this.type);
9169	}
9170	/**
9171	* @param {StructStore} store
9172	*/
9173	gc(store) {
9174	let item = this.type._start;
9175	while (item !== null) {
9176	item.gc(store, true);
9177	item = item.right;
9178	}
9179	this.type._start = null;
9180	this.type._map.forEach(
9181	/** @param {Item \| null} item */
9182	(item2) => {
9183	while (item2 !== null) {
9184	item2.gc(store, true);
9185	item2 = item2.left;
9186	}
9187	}
9188	);
9189	this.type._map = /* @__PURE__ */ new Map();
9190	}
9191	/**
9192	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
9193	* @param {number} offset
9194	*/
9195	write(encoder, offset) {
9196	this.type._write(encoder);
9197	}
9198	/**
9199	* @return {number}
9200	*/
9201	getRef() {
9202	return 7;
9203	}
9204	};
9205	var readContentType = (decoder) => new ContentType(typeRefs[decoder.readTypeRef()](decoder));
9206	var followRedone = (store, id2) => {
9207	let nextID = id2;
9208	let diff = 0;
9209	let item;
9210	do {
9211	if (diff > 0) {
9212	nextID = createID(nextID.client, nextID.clock + diff);
9213	}
9214	item = getItem(store, nextID);
9215	diff = nextID.clock - item.id.clock;
9216	nextID = item.redone;
9217	} while (nextID !== null && item instanceof Item);
9218	return {
9219	item,
9220	diff
9221	};
9222	};
9223	var keepItem = (item, keep) => {
9224	while (item !== null && item.keep !== keep) {
9225	item.keep = keep;
9226	item = /** @type {AbstractType<any>} */
9227	item.parent._item;
9228	}
9229	};
9230	var splitItem = (transaction, leftItem, diff) => {
9231	const { client, clock } = leftItem.id;
9232	const rightItem = new Item(
9233	createID(client, clock + diff),
9234	leftItem,
9235	createID(client, clock + diff - 1),
9236	leftItem.right,
9237	leftItem.rightOrigin,
9238	leftItem.parent,
9239	leftItem.parentSub,
9240	leftItem.content.splice(diff)
9241	);
9242	if (leftItem.deleted) {
9243	rightItem.markDeleted();
9244	}
9245	if (leftItem.keep) {
9246	rightItem.keep = true;
9247	}
9248	if (leftItem.redone !== null) {
9249	rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff);
9250	}
9251	leftItem.right = rightItem;
9252	if (rightItem.right !== null) {
9253	rightItem.right.left = rightItem;
9254	}
9255	transaction._mergeStructs.push(rightItem);
9256	if (rightItem.parentSub !== null && rightItem.right === null) {
9257	rightItem.parent._map.set(rightItem.parentSub, rightItem);
9258	}
9259	leftItem.length = diff;
9260	return rightItem;
9261	};
9262	var isDeletedByUndoStack = (stack, id2) => some(
9263	stack,
9264	/** @param {StackItem} s */
9265	(s) => isDeleted(s.deletions, id2)
9266	);
9267	var redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) => {
9268	const doc2 = transaction.doc;
9269	const store = doc2.store;
9270	const ownClientID = doc2.clientID;
9271	const redone = item.redone;
9272	if (redone !== null) {
9273	return getItemCleanStart(transaction, redone);
9274	}
9275	let parentItem = (
9276	/** @type {AbstractType<any>} */
9277	item.parent._item
9278	);
9279	let left = null;
9280	let right;
9281	if (parentItem !== null && parentItem.deleted === true) {
9282	if (parentItem.redone === null && (!redoitems.has(parentItem) \|\| redoItem(transaction, parentItem, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) === null)) {
9283	return null;
9284	}
9285	while (parentItem.redone !== null) {
9286	parentItem = getItemCleanStart(transaction, parentItem.redone);
9287	}
9288	}
9289	const parentType = parentItem === null ? (
9290	/** @type {AbstractType<any>} */
9291	item.parent
9292	) : (
9293	/** @type {ContentType} */
9294	parentItem.content.type
9295	);
9296	if (item.parentSub === null) {
9297	left = item.left;
9298	right = item;
9299	while (left !== null) {
9300	let leftTrace = left;
9301	while (leftTrace !== null && /** @type {AbstractType<any>} */
9302	leftTrace.parent._item !== parentItem) {
9303	leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone);
9304	}
9305	if (leftTrace !== null && /** @type {AbstractType<any>} */
9306	leftTrace.parent._item === parentItem) {
9307	left = leftTrace;
9308	break;
9309	}
9310	left = left.left;
9311	}
9312	while (right !== null) {
9313	let rightTrace = right;
9314	while (rightTrace !== null && /** @type {AbstractType<any>} */
9315	rightTrace.parent._item !== parentItem) {
9316	rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone);
9317	}
9318	if (rightTrace !== null && /** @type {AbstractType<any>} */
9319	rightTrace.parent._item === parentItem) {
9320	right = rightTrace;
9321	break;
9322	}
9323	right = right.right;
9324	}
9325	} else {
9326	right = null;
9327	if (item.right && !ignoreRemoteMapChanges) {
9328	left = item;
9329	while (left !== null && left.right !== null && (left.right.redone \|\| isDeleted(itemsToDelete, left.right.id) \|\| isDeletedByUndoStack(um.undoStack, left.right.id) \|\| isDeletedByUndoStack(um.redoStack, left.right.id))) {
9330	left = left.right;
9331	while (left.redone) left = getItemCleanStart(transaction, left.redone);
9332	}
9333	if (left && left.right !== null) {
9334	return null;
9335	}
9336	} else {
9337	left = parentType._map.get(item.parentSub) \|\| null;
9338	}
9339	}
9340	const nextClock = getState(store, ownClientID);
9341	const nextId = createID(ownClientID, nextClock);
9342	const redoneItem = new Item(
9343	nextId,
9344	left,
9345	left && left.lastId,
9346	right,
9347	right && right.id,
9348	parentType,
9349	item.parentSub,
9350	item.content.copy()
9351	);
9352	item.redone = nextId;
9353	keepItem(redoneItem, true);
9354	redoneItem.integrate(transaction, 0);
9355	return redoneItem;
9356	};
9357	var Item = class _Item extends AbstractStruct {
9358	/**
9359	* @param {ID} id
9360	* @param {Item \| null} left
9361	* @param {ID \| null} origin
9362	* @param {Item \| null} right
9363	* @param {ID \| null} rightOrigin
9364	* @param {AbstractType<any>\|ID\|null} parent Is a type if integrated, is null if it is possible to copy parent from left or right, is ID before integration to search for it.
9365	* @param {string \| null} parentSub
9366	* @param {AbstractContent} content
9367	*/
9368	constructor(id2, left, origin2, right, rightOrigin, parent, parentSub, content) {
9369	super(id2, content.getLength());
9370	this.origin = origin2;
9371	this.left = left;
9372	this.right = right;
9373	this.rightOrigin = rightOrigin;
9374	this.parent = parent;
9375	this.parentSub = parentSub;
9376	this.redone = null;
9377	this.content = content;
9378	this.info = this.content.isCountable() ? BIT2 : 0;
9379	}
9380	/**
9381	* This is used to mark the item as an indexed fast-search marker
9382	*
9383	* @type {boolean}
9384	*/
9385	set marker(isMarked) {
9386	if ((this.info & BIT4) > 0 !== isMarked) {
9387	this.info ^= BIT4;
9388	}
9389	}
9390	get marker() {
9391	return (this.info & BIT4) > 0;
9392	}
9393	/**
9394	* If true, do not garbage collect this Item.
9395	*/
9396	get keep() {
9397	return (this.info & BIT1) > 0;
9398	}
9399	set keep(doKeep) {
9400	if (this.keep !== doKeep) {
9401	this.info ^= BIT1;
9402	}
9403	}
9404	get countable() {
9405	return (this.info & BIT2) > 0;
9406	}
9407	/**
9408	* Whether this item was deleted or not.
9409	* @type {Boolean}
9410	*/
9411	get deleted() {
9412	return (this.info & BIT3) > 0;
9413	}
9414	set deleted(doDelete) {
9415	if (this.deleted !== doDelete) {
9416	this.info ^= BIT3;
9417	}
9418	}
9419	markDeleted() {
9420	this.info \|= BIT3;
9421	}
9422	/**
9423	* Return the creator clientID of the missing op or define missing items and return null.
9424	*
9425	* @param {Transaction} transaction
9426	* @param {StructStore} store
9427	* @return {null \| number}
9428	*/
9429	getMissing(transaction, store) {
9430	if (this.origin && this.origin.client !== this.id.client && this.origin.clock >= getState(store, this.origin.client)) {
9431	return this.origin.client;
9432	}
9433	if (this.rightOrigin && this.rightOrigin.client !== this.id.client && this.rightOrigin.clock >= getState(store, this.rightOrigin.client)) {
9434	return this.rightOrigin.client;
9435	}
9436	if (this.parent && this.parent.constructor === ID && this.id.client !== this.parent.client && this.parent.clock >= getState(store, this.parent.client)) {
9437	return this.parent.client;
9438	}
9439	if (this.origin) {
9440	this.left = getItemCleanEnd(transaction, store, this.origin);
9441	this.origin = this.left.lastId;
9442	}
9443	if (this.rightOrigin) {
9444	this.right = getItemCleanStart(transaction, this.rightOrigin);
9445	this.rightOrigin = this.right.id;
9446	}
9447	if (this.left && this.left.constructor === GC \|\| this.right && this.right.constructor === GC) {
9448	this.parent = null;
9449	} else if (!this.parent) {
9450	if (this.left && this.left.constructor === _Item) {
9451	this.parent = this.left.parent;
9452	this.parentSub = this.left.parentSub;
9453	} else if (this.right && this.right.constructor === _Item) {
9454	this.parent = this.right.parent;
9455	this.parentSub = this.right.parentSub;
9456	}
9457	} else if (this.parent.constructor === ID) {
9458	const parentItem = getItem(store, this.parent);
9459	if (parentItem.constructor === GC) {
9460	this.parent = null;
9461	} else {
9462	this.parent = /** @type {ContentType} */
9463	parentItem.content.type;
9464	}
9465	}
9466	return null;
9467	}
9468	/**
9469	* @param {Transaction} transaction
9470	* @param {number} offset
9471	*/
9472	integrate(transaction, offset) {
9473	if (offset > 0) {
9474	this.id.clock += offset;
9475	this.left = getItemCleanEnd(transaction, transaction.doc.store, createID(this.id.client, this.id.clock - 1));
9476	this.origin = this.left.lastId;
9477	this.content = this.content.splice(offset);
9478	this.length -= offset;
9479	}
9480	if (this.parent) {
9481	if (!this.left && (!this.right \|\| this.right.left !== null) \|\| this.left && this.left.right !== this.right) {
9482	let left = this.left;
9483	let o;
9484	if (left !== null) {
9485	o = left.right;
9486	} else if (this.parentSub !== null) {
9487	o = /** @type {AbstractType<any>} */
9488	this.parent._map.get(this.parentSub) \|\| null;
9489	while (o !== null && o.left !== null) {
9490	o = o.left;
9491	}
9492	} else {
9493	o = /** @type {AbstractType<any>} */
9494	this.parent._start;
9495	}
9496	const conflictingItems = /* @__PURE__ */ new Set();
9497	const itemsBeforeOrigin = /* @__PURE__ */ new Set();
9498	while (o !== null && o !== this.right) {
9499	itemsBeforeOrigin.add(o);
9500	conflictingItems.add(o);
9501	if (compareIDs(this.origin, o.origin)) {
9502	if (o.id.client < this.id.client) {
9503	left = o;
9504	conflictingItems.clear();
9505	} else if (compareIDs(this.rightOrigin, o.rightOrigin)) {
9506	break;
9507	}
9508	} else if (o.origin !== null && itemsBeforeOrigin.has(getItem(transaction.doc.store, o.origin))) {
9509	if (!conflictingItems.has(getItem(transaction.doc.store, o.origin))) {
9510	left = o;
9511	conflictingItems.clear();
9512	}
9513	} else {
9514	break;
9515	}
9516	o = o.right;
9517	}
9518	this.left = left;
9519	}
9520	if (this.left !== null) {
9521	const right = this.left.right;
9522	this.right = right;
9523	this.left.right = this;
9524	} else {
9525	let r;
9526	if (this.parentSub !== null) {
9527	r = /** @type {AbstractType<any>} */
9528	this.parent._map.get(this.parentSub) \|\| null;
9529	while (r !== null && r.left !== null) {
9530	r = r.left;
9531	}
9532	} else {
9533	r = /** @type {AbstractType<any>} */
9534	this.parent._start;
9535	this.parent._start = this;
9536	}
9537	this.right = r;
9538	}
9539	if (this.right !== null) {
9540	this.right.left = this;
9541	} else if (this.parentSub !== null) {
9542	this.parent._map.set(this.parentSub, this);
9543	if (this.left !== null) {
9544	this.left.delete(transaction);
9545	}
9546	}
9547	if (this.parentSub === null && this.countable && !this.deleted) {
9548	this.parent._length += this.length;
9549	}
9550	addStruct(transaction.doc.store, this);
9551	this.content.integrate(transaction, this);
9552	addChangedTypeToTransaction(
9553	transaction,
9554	/** @type {AbstractType<any>} */
9555	this.parent,
9556	this.parentSub
9557	);
9558	if (
9559	/** @type {AbstractType<any>} */
9560	this.parent._item !== null && /** @type {AbstractType<any>} */
9561	this.parent._item.deleted \|\| this.parentSub !== null && this.right !== null
9562	) {
9563	this.delete(transaction);
9564	}
9565	} else {
9566	new GC(this.id, this.length).integrate(transaction, 0);
9567	}
9568	}
9569	/**
9570	* Returns the next non-deleted item
9571	*/
9572	get next() {
9573	let n = this.right;
9574	while (n !== null && n.deleted) {
9575	n = n.right;
9576	}
9577	return n;
9578	}
9579	/**
9580	* Returns the previous non-deleted item
9581	*/
9582	get prev() {
9583	let n = this.left;
9584	while (n !== null && n.deleted) {
9585	n = n.left;
9586	}
9587	return n;
9588	}
9589	/**
9590	* Computes the last content address of this Item.
9591	*/
9592	get lastId() {
9593	return this.length === 1 ? this.id : createID(this.id.client, this.id.clock + this.length - 1);
9594	}
9595	/**
9596	* Try to merge two items
9597	*
9598	* @param {Item} right
9599	* @return {boolean}
9600	*/
9601	mergeWith(right) {
9602	if (this.constructor === right.constructor && compareIDs(right.origin, this.lastId) && this.right === right && compareIDs(this.rightOrigin, right.rightOrigin) && this.id.client === right.id.client && this.id.clock + this.length === right.id.clock && this.deleted === right.deleted && this.redone === null && right.redone === null && this.content.constructor === right.content.constructor && this.content.mergeWith(right.content)) {
9603	const searchMarker = (
9604	/** @type {AbstractType<any>} */
9605	this.parent._searchMarker
9606	);
9607	if (searchMarker) {
9608	searchMarker.forEach((marker) => {
9609	if (marker.p === right) {
9610	marker.p = this;
9611	if (!this.deleted && this.countable) {
9612	marker.index -= this.length;
9613	}
9614	}
9615	});
9616	}
9617	if (right.keep) {
9618	this.keep = true;
9619	}
9620	this.right = right.right;
9621	if (this.right !== null) {
9622	this.right.left = this;
9623	}
9624	this.length += right.length;
9625	return true;
9626	}
9627	return false;
9628	}
9629	/**
9630	* Mark this Item as deleted.
9631	*
9632	* @param {Transaction} transaction
9633	*/
9634	delete(transaction) {
9635	if (!this.deleted) {
9636	const parent = (
9637	/** @type {AbstractType<any>} */
9638	this.parent
9639	);
9640	if (this.countable && this.parentSub === null) {
9641	parent._length -= this.length;
9642	}
9643	this.markDeleted();
9644	addToDeleteSet(transaction.deleteSet, this.id.client, this.id.clock, this.length);
9645	addChangedTypeToTransaction(transaction, parent, this.parentSub);
9646	this.content.delete(transaction);
9647	}
9648	}
9649	/**
9650	* @param {StructStore} store
9651	* @param {boolean} parentGCd
9652	*/
9653	gc(store, parentGCd) {
9654	if (!this.deleted) {
9655	throw unexpectedCase();
9656	}
9657	this.content.gc(store);
9658	if (parentGCd) {
9659	replaceStruct(store, this, new GC(this.id, this.length));
9660	} else {
9661	this.content = new ContentDeleted(this.length);
9662	}
9663	}
9664	/**
9665	* Transform the properties of this type to binary and write it to an
9666	* BinaryEncoder.
9667	*
9668	* This is called when this Item is sent to a remote peer.
9669	*
9670	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder The encoder to write data to.
9671	* @param {number} offset
9672	*/
9673	write(encoder, offset) {
9674	const origin2 = offset > 0 ? createID(this.id.client, this.id.clock + offset - 1) : this.origin;
9675	const rightOrigin = this.rightOrigin;
9676	const parentSub = this.parentSub;
9677	const info = this.content.getRef() & BITS5 \| (origin2 === null ? 0 : BIT8) \| // origin is defined
9678	(rightOrigin === null ? 0 : BIT7) \| // right origin is defined
9679	(parentSub === null ? 0 : BIT6);
9680	encoder.writeInfo(info);
9681	if (origin2 !== null) {
9682	encoder.writeLeftID(origin2);
9683	}
9684	if (rightOrigin !== null) {
9685	encoder.writeRightID(rightOrigin);
9686	}
9687	if (origin2 === null && rightOrigin === null) {
9688	const parent = (
9689	/** @type {AbstractType<any>} */
9690	this.parent
9691	);
9692	if (parent._item !== void 0) {
9693	const parentItem = parent._item;
9694	if (parentItem === null) {
9695	const ykey = findRootTypeKey(parent);
9696	encoder.writeParentInfo(true);
9697	encoder.writeString(ykey);
9698	} else {
9699	encoder.writeParentInfo(false);
9700	encoder.writeLeftID(parentItem.id);
9701	}
9702	} else if (parent.constructor === String) {
9703	encoder.writeParentInfo(true);
9704	encoder.writeString(parent);
9705	} else if (parent.constructor === ID) {
9706	encoder.writeParentInfo(false);
9707	encoder.writeLeftID(parent);
9708	} else {
9709	unexpectedCase();
9710	}
9711	if (parentSub !== null) {
9712	encoder.writeString(parentSub);
9713	}
9714	}
9715	this.content.write(encoder, offset);
9716	}
9717	};
9718	var readItemContent = (decoder, info) => contentRefs[info & BITS5](decoder);
9719	var contentRefs = [
9720	() => {
9721	unexpectedCase();
9722	},
9723	// GC is not ItemContent
9724	readContentDeleted,
9725	// 1
9726	readContentJSON,
9727	// 2
9728	readContentBinary,
9729	// 3
9730	readContentString,
9731	// 4
9732	readContentEmbed,
9733	// 5
9734	readContentFormat,
9735	// 6
9736	readContentType,
9737	// 7
9738	readContentAny,
9739	// 8
9740	readContentDoc,
9741	// 9
9742	() => {
9743	unexpectedCase();
9744	}
9745	// 10 - Skip is not ItemContent
9746	];
9747	var structSkipRefNumber = 10;
9748	var Skip = class extends AbstractStruct {
9749	get deleted() {
9750	return true;
9751	}
9752	delete() {
9753	}
9754	/**
9755	* @param {Skip} right
9756	* @return {boolean}
9757	*/
9758	mergeWith(right) {
9759	if (this.constructor !== right.constructor) {
9760	return false;
9761	}
9762	this.length += right.length;
9763	return true;
9764	}
9765	/**
9766	* @param {Transaction} transaction
9767	* @param {number} offset
9768	*/
9769	integrate(transaction, offset) {
9770	unexpectedCase();
9771	}
9772	/**
9773	* @param {UpdateEncoderV1 \| UpdateEncoderV2} encoder
9774	* @param {number} offset
9775	*/
9776	write(encoder, offset) {
9777	encoder.writeInfo(structSkipRefNumber);
9778	writeVarUint(encoder.restEncoder, this.length - offset);
9779	}
9780	/**
9781	* @param {Transaction} transaction
9782	* @param {StructStore} store
9783	* @return {null \| number}
9784	*/
9785	getMissing(transaction, store) {
9786	return null;
9787	}
9788	};
9789	var glo = (
9790	/** @type {any} */
9791	typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {}
9792	);
9793	var importIdentifier = "__ $YJS$ __";
9794	if (glo[importIdentifier] === true) {
9795	console.error("Yjs was already imported. This breaks constructor checks and will lead to issues! - https://github.com/yjs/yjs/issues/438");
9796	}
9797	glo[importIdentifier] = true;
9798
9799	// node_modules/y-protocols/awareness.js
9800	var outdatedTimeout = 3e4;
9801	var Awareness = class extends Observable {
9802	/**
9803	* @param {Y.Doc} doc
9804	*/
9805	constructor(doc2) {
9806	super();
9807	this.doc = doc2;
9808	this.clientID = doc2.clientID;
9809	this.states = /* @__PURE__ */ new Map();
9810	this.meta = /* @__PURE__ */ new Map();
9811	this._checkInterval = /** @type {any} */
9812	setInterval(() => {
9813	const now = getUnixTime();
9814	if (this.getLocalState() !== null && outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */
9815	this.meta.get(this.clientID).lastUpdated) {
9816	this.setLocalState(this.getLocalState());
9817	}
9818	const remove = [];
9819	this.meta.forEach((meta, clientid) => {
9820	if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
9821	remove.push(clientid);
9822	}
9823	});
9824	if (remove.length > 0) {
9825	removeAwarenessStates(this, remove, "timeout");
9826	}
9827	}, floor(outdatedTimeout / 10));
9828	doc2.on("destroy", () => {
9829	this.destroy();
9830	});
9831	this.setLocalState({});
9832	}
9833	destroy() {
9834	this.emit("destroy", [this]);
9835	this.setLocalState(null);
9836	super.destroy();
9837	clearInterval(this._checkInterval);
9838	}
9839	/**
9840	* @return {Object<string,any>\|null}
9841	*/
9842	getLocalState() {
9843	return this.states.get(this.clientID) \|\| null;
9844	}
9845	/**
9846	* @param {Object<string,any>\|null} state
9847	*/
9848	setLocalState(state) {
9849	const clientID = this.clientID;
9850	const currLocalMeta = this.meta.get(clientID);
9851	const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
9852	const prevState = this.states.get(clientID);
9853	if (state === null) {
9854	this.states.delete(clientID);
9855	} else {
9856	this.states.set(clientID, state);
9857	}
9858	this.meta.set(clientID, {
9859	clock,
9860	lastUpdated: getUnixTime()
9861	});
9862	const added = [];
9863	const updated = [];
9864	const filteredUpdated = [];
9865	const removed = [];
9866	if (state === null) {
9867	removed.push(clientID);
9868	} else if (prevState == null) {
9869	if (state != null) {
9870	added.push(clientID);
9871	}
9872	} else {
9873	updated.push(clientID);
9874	if (!equalityDeep(prevState, state)) {
9875	filteredUpdated.push(clientID);
9876	}
9877	}
9878	if (added.length > 0 \|\| filteredUpdated.length > 0 \|\| removed.length > 0) {
9879	this.emit("change", [{ added, updated: filteredUpdated, removed }, "local"]);
9880	}
9881	this.emit("update", [{ added, updated, removed }, "local"]);
9882	}
9883	/**
9884	* @param {string} field
9885	* @param {any} value
9886	*/
9887	setLocalStateField(field, value) {
9888	const state = this.getLocalState();
9889	if (state !== null) {
9890	this.setLocalState({
9891	...state,
9892	[field]: value
9893	});
9894	}
9895	}
9896	/**
9897	* @return {Map<number,Object<string,any>>}
9898	*/
9899	getStates() {
9900	return this.states;
9901	}
9902	};
9903	var removeAwarenessStates = (awareness, clients, origin2) => {
9904	const removed = [];
9905	for (let i = 0; i < clients.length; i++) {
9906	const clientID = clients[i];
9907	if (awareness.states.has(clientID)) {
9908	awareness.states.delete(clientID);
9909	if (clientID === awareness.clientID) {
9910	const curMeta = (
9911	/** @type {MetaClientState} */
9912	awareness.meta.get(clientID)
9913	);
9914	awareness.meta.set(clientID, {
9915	clock: curMeta.clock + 1,
9916	lastUpdated: getUnixTime()
9917	});
9918	}
9919	removed.push(clientID);
9920	}
9921	}
9922	if (removed.length > 0) {
9923	awareness.emit("change", [{ added: [], updated: [], removed }, origin2]);
9924	awareness.emit("update", [{ added: [], updated: [], removed }, origin2]);
9925	}
9926	};
9927
9928	// packages/sync/build-module/config.mjs
9929	var CRDT_DOC_VERSION = 1;
9930	var CRDT_DOC_META_PERSISTENCE_KEY = "fromPersistence";
9931	var CRDT_RECORD_MAP_KEY = "document";
9932	var CRDT_STATE_MAP_KEY = "state";
9933	var CRDT_STATE_MAP_SAVED_AT_KEY = "savedAt";
9934	var CRDT_STATE_MAP_SAVED_BY_KEY = "savedBy";
9935	var CRDT_STATE_MAP_VERSION_KEY = "version";
9936	var LOCAL_EDITOR_ORIGIN = "gutenberg";
9937	var LOCAL_SYNC_MANAGER_ORIGIN = "syncManager";
9938	var LOCAL_UNDO_IGNORED_ORIGIN = "gutenberg-undo-ignored";
9939
9940	// packages/sync/build-module/errors.mjs
9941	var ConnectionErrorCode = /* @__PURE__ */ ((ConnectionErrorCode2) => {
9942	ConnectionErrorCode2["AUTHENTICATION_FAILED"] = "authentication-failed";
9943	ConnectionErrorCode2["CONNECTION_EXPIRED"] = "connection-expired";
9944	ConnectionErrorCode2["CONNECTION_LIMIT_EXCEEDED"] = "connection-limit-exceeded";
9945	ConnectionErrorCode2["DOCUMENT_SIZE_LIMIT_EXCEEDED"] = "document-size-limit-exceeded";
9946	ConnectionErrorCode2["PROTOCOL_MISMATCH"] = "protocol-mismatch";
9947	ConnectionErrorCode2["UNKNOWN_ERROR"] = "unknown-error";
9948	return ConnectionErrorCode2;
9949	})(ConnectionErrorCode \|\| {});
9950	var ConnectionError = class extends Error {
9951	constructor(code = "unknown-error", message) {
9952	super(message);
9953	this.code = code;
9954	this.name = "ConnectionError";
9955	}
9956	};
9957
9958	// packages/sync/build-module/lock-unlock.mjs
9959	var import_private_apis = __toESM(require_private_apis(), 1);
9960	var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
9961	"I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
9962	"@wordpress/sync"
9963	);
9964
9965	// packages/sync/build-module/performance.mjs
9966	function logPerformanceTiming(fn) {
9967	return function(...args2) {
9968	const start = performance.now();
9969	const result = fn.apply(this, args2);
9970	const end = performance.now();
9971	console.log(
9972	`[SyncManager][performance]: ${fn.name} took ${(end - start).toFixed(2)} ms`
9973	);
9974	return result;
9975	};
9976	}
9977	function passThru(fn) {
9978	return ((...args2) => fn(...args2));
9979	}
9980	function yieldToEventLoop(fn) {
9981	return function(...args2) {
9982	setTimeout(() => {
9983	fn.apply(this, args2);
9984	}, 0);
9985	};
9986	}
9987
9988	// packages/sync/build-module/providers/index.mjs
9989	var import_hooks3 = __toESM(require_hooks(), 1);
9990
9991	// packages/sync/build-module/providers/http-polling/polling-manager.mjs
9992	var import_hooks2 = __toESM(require_hooks(), 1);
9993
9994	// node_modules/y-protocols/sync.js
9995	var messageYjsSyncStep1 = 0;
9996	var messageYjsSyncStep2 = 1;
9997	var messageYjsUpdate = 2;
9998	var writeSyncStep1 = (encoder, doc2) => {
9999	writeVarUint(encoder, messageYjsSyncStep1);
10000	const sv = encodeStateVector(doc2);
10001	writeVarUint8Array(encoder, sv);
10002	};
10003	var writeSyncStep2 = (encoder, doc2, encodedStateVector) => {
10004	writeVarUint(encoder, messageYjsSyncStep2);
10005	writeVarUint8Array(encoder, encodeStateAsUpdate(doc2, encodedStateVector));
10006	};
10007	var readSyncStep1 = (decoder, encoder, doc2) => writeSyncStep2(encoder, doc2, readVarUint8Array(decoder));
10008	var readSyncStep2 = (decoder, doc2, transactionOrigin, errorHandler) => {
10009	try {
10010	applyUpdate(doc2, readVarUint8Array(decoder), transactionOrigin);
10011	} catch (error) {
10012	if (errorHandler != null) errorHandler(
10013	/** @type {Error} */
10014	error
10015	);
10016	console.error("Caught error while handling a Yjs update", error);
10017	}
10018	};
10019	var readUpdate2 = readSyncStep2;
10020	var readSyncMessage = (decoder, encoder, doc2, transactionOrigin, errorHandler) => {
10021	const messageType = readVarUint(decoder);
10022	switch (messageType) {
10023	case messageYjsSyncStep1:
10024	readSyncStep1(decoder, encoder, doc2);
10025	break;
10026	case messageYjsSyncStep2:
10027	readSyncStep2(decoder, doc2, transactionOrigin, errorHandler);
10028	break;
10029	case messageYjsUpdate:
10030	readUpdate2(decoder, doc2, transactionOrigin, errorHandler);
10031	break;
10032	default:
10033	throw new Error("Unknown message type");
10034	}
10035	return messageType;
10036	};
10037
10038	// packages/sync/build-module/providers/http-polling/config.mjs
10039	var import_hooks = __toESM(require_hooks(), 1);
10040	var DEFAULT_CLIENT_LIMIT_PER_ROOM = 3;
10041	var ERROR_RETRY_DELAYS_SOLO_MS = [
10042	2e3,
10043	4e3,
10044	8e3,
10045	12e3
10046	// Solo: 26s total retry time solo before dialog
10047	];
10048	var ERROR_RETRY_DELAYS_WITH_COLLABORATORS_MS = [
10049	1e3,
10050	2e3,
10051	4e3,
10052	8e3
10053	// With collaborators: 15s total retry time before dialog
10054	];
10055	var DISCONNECT_DIALOG_RETRY_MS = 3e4;
10056	var MANUAL_RETRY_INTERVAL_MS = 15e3;
10057	var MAX_ENCODED_UPDATE_SIZE_IN_BYTES = 1 * 1024 * 1024;
10058	var MAX_UPDATE_SIZE_IN_BYTES = Math.floor(MAX_ENCODED_UPDATE_SIZE_IN_BYTES / 4) * 3;
10059	var MAX_ROOMS_PER_REQUEST = 50;
10060	var MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES = 15 * 1024 * 1024;
10061	var MIN_SYNC_REQUEST_BODY_SIZE_LIMIT_IN_BYTES = 2 * 1024 * 1024;
10062	var DEFAULT_POLLING_INTERVAL_IN_MS = 4e3;
10063	var DEFAULT_POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS = 1e3;
10064	function getFilteredPollingInterval(hookName, defaultInterval) {
10065	const filteredInterval = (0, import_hooks.applyFilters)(hookName, defaultInterval);
10066	if (typeof filteredInterval !== "number" \|\| !Number.isFinite(filteredInterval) \|\| filteredInterval <= 0) {
10067	return defaultInterval;
10068	}
10069	return Math.min(filteredInterval, defaultInterval);
10070	}
10071	var POLLING_INTERVAL_IN_MS = getFilteredPollingInterval(
10072	"sync.pollingManager.pollingInterval",
10073	DEFAULT_POLLING_INTERVAL_IN_MS
10074	);
10075	var POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS = getFilteredPollingInterval(
10076	"sync.pollingManager.pollingIntervalWithCollaborators",
10077	DEFAULT_POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS
10078	);
10079	var POLLING_INTERVAL_BACKGROUND_TAB_IN_MS = 25 * 1e3;
10080
10081	// packages/sync/build-module/providers/http-polling/types.mjs
10082	var SyncUpdateType = /* @__PURE__ */ ((SyncUpdateType2) => {
10083	SyncUpdateType2["COMPACTION"] = "compaction";
10084	SyncUpdateType2["SYNC_STEP_1"] = "sync_step1";
10085	SyncUpdateType2["SYNC_STEP_2"] = "sync_step2";
10086	SyncUpdateType2["UPDATE"] = "update";
10087	return SyncUpdateType2;
10088	})(SyncUpdateType \|\| {});
10089
10090	// packages/sync/build-module/providers/http-polling/utils.mjs
10091	var import_api_fetch = __toESM(require_api_fetch(), 1);
10092	var SYNC_API_PATH = "/wp-sync/v1/updates";
10093	function uint8ArrayToBase64(data) {
10094	let binary = "";
10095	const len = data.byteLength;
10096	for (let i = 0; i < len; i++) {
10097	binary += String.fromCharCode(data[i]);
10098	}
10099	return globalThis.btoa(binary);
10100	}
10101	function base64ToUint8Array(base64) {
10102	const binaryString = globalThis.atob(base64);
10103	const len = binaryString.length;
10104	const bytes = new Uint8Array(len);
10105	for (let i = 0; i < len; i++) {
10106	bytes[i] = binaryString.charCodeAt(i);
10107	}
10108	return bytes;
10109	}
10110	function createSyncUpdate(data, type) {
10111	return {
10112	data: uint8ArrayToBase64(data),
10113	type
10114	};
10115	}
10116	function createUpdateQueue(initial = [], paused = true) {
10117	let isPaused = paused;
10118	const updates = [...initial];
10119	return {
10120	add(update) {
10121	updates.push(update);
10122	},
10123	addBulk(bulkUpdates) {
10124	if (0 === bulkUpdates.length) {
10125	return;
10126	}
10127	updates.push(...bulkUpdates);
10128	},
10129	clear() {
10130	updates.splice(0, updates.length);
10131	},
10132	get() {
10133	if (isPaused) {
10134	return [];
10135	}
10136	return updates.splice(0, updates.length);
10137	},
10138	pause() {
10139	isPaused = true;
10140	},
10141	peek() {
10142	if (isPaused) {
10143	return [];
10144	}
10145	return [...updates];
10146	},
10147	restore(restoredUpdates) {
10148	const filtered = restoredUpdates.filter(
10149	(u) => u.type !== SyncUpdateType.COMPACTION
10150	);
10151	if (0 === filtered.length) {
10152	return;
10153	}
10154	updates.unshift(...filtered);
10155	},
10156	restoreExact(restoredUpdates) {
10157	if (0 === restoredUpdates.length) {
10158	return;
10159	}
10160	updates.unshift(...restoredUpdates);
10161	},
10162	resume() {
10163	isPaused = false;
10164	},
10165	size() {
10166	return updates.length;
10167	},
10168	take(count) {
10169	if (isPaused \|\| count <= 0) {
10170	return [];
10171	}
10172	return updates.splice(0, count);
10173	}
10174	};
10175	}
10176	function postSyncUpdate(payload) {
10177	return (0, import_api_fetch.default)({
10178	method: "POST",
10179	path: SYNC_API_PATH,
10180	data: payload
10181	});
10182	}
10183	function postSyncUpdateNonBlocking(payload) {
10184	if (payload.rooms.length === 0) {
10185	return;
10186	}
10187	(0, import_api_fetch.default)({
10188	method: "POST",
10189	path: SYNC_API_PATH,
10190	data: payload,
10191	keepalive: true
10192	}).catch(() => {
10193	});
10194	}
10195	function intValueOrDefault(value, defaultValue) {
10196	const intValue = parseInt(String(value), 10);
10197	return isNaN(intValue) ? defaultValue : intValue;
10198	}
10199	function rotateWindow(items, offset, size2) {
10200	if (items.length === 0) {
10201	return { window: [], nextOffset: 0 };
10202	}
10203	const start = (offset % items.length + items.length) % items.length;
10204	const wrapped = [...items.slice(start), ...items.slice(0, start)];
10205	return {
10206	window: wrapped.slice(0, Math.max(0, size2)),
10207	nextOffset: (start + Math.max(0, size2)) % items.length
10208	};
10209	}
10210
10211	// packages/sync/build-module/providers/http-polling/polling-manager.mjs
10212	var POLLING_MANAGER_ORIGIN = "polling-manager";
10213	function isForbiddenError(error) {
10214	return error?.data?.status === 403;
10215	}
10216	function isRequestBodyTooLargeError(error) {
10217	return error?.data?.status === 413 && error?.code === "rest_sync_body_too_large";
10218	}
10219	function isProtocolMismatchError(error) {
10220	return error?.code === "rest_sync_protocol_mismatch";
10221	}
10222	function handleForbiddenError(error, requestedRooms) {
10223	const requestedRoomNames = new Set(
10224	requestedRooms.map((room) => room.room)
10225	);
10226	const forbiddenRooms = Array.isArray(error.data.rooms) ? error.data.rooms.filter((room) => requestedRoomNames.has(room)) : [];
10227	if (forbiddenRooms.length > 0) {
10228	for (const room of forbiddenRooms) {
10229	const state = roomStates.get(room);
10230	if (state) {
10231	state.log(
10232	"Permission denied, unregistering room",
10233	{ error },
10234	"error",
10235	true
10236	// force
10237	);
10238	unregisterRoom(room, { sendDisconnectSignal: false });
10239	}
10240	}
10241	for (const room of requestedRooms) {
10242	if (forbiddenRooms.includes(room.room)) {
10243	continue;
10244	}
10245	if (!roomStates.has(room.room)) {
10246	continue;
10247	}
10248	const remainingState = roomStates.get(room.room);
10249	if (room.updates.length > 0) {
10250	remainingState.updateQueue.restore(room.updates);
10251	}
10252	}
10253	} else {
10254	const rooms = [...roomStates.keys()];
10255	for (const room of rooms) {
10256	const state = roomStates.get(room);
10257	if (state) {
10258	state.log(
10259	"Permission denied, unregistering room",
10260	{ error },
10261	"error",
10262	true
10263	// force
10264	);
10265	unregisterRoom(room, { sendDisconnectSignal: false });
10266	}
10267	}
10268	}
10269	}
10270	var roomStates = /* @__PURE__ */ new Map();
10271	function createDeprecatedCompactionUpdate(updates) {
10272	const mergeable = updates.filter(
10273	(u) => [SyncUpdateType.COMPACTION, SyncUpdateType.UPDATE].includes(
10274	u.type
10275	)
10276	).map((u) => base64ToUint8Array(u.data));
10277	return createSyncUpdate(
10278	mergeUpdatesV2(mergeable),
10279	SyncUpdateType.COMPACTION
10280	);
10281	}
10282	function createSyncStep1Update(doc2) {
10283	const encoder = createEncoder();
10284	writeSyncStep1(encoder, doc2);
10285	return createSyncUpdate(
10286	toUint8Array(encoder),
10287	SyncUpdateType.SYNC_STEP_1
10288	);
10289	}
10290	function createSyncStep2Update(doc2, step1) {
10291	const decoder = createDecoder(step1);
10292	const encoder = createEncoder();
10293	readSyncMessage(
10294	decoder,
10295	encoder,
10296	doc2,
10297	POLLING_MANAGER_ORIGIN
10298	);
10299	return createSyncUpdate(
10300	toUint8Array(encoder),
10301	SyncUpdateType.SYNC_STEP_2
10302	);
10303	}
10304	function processAwarenessUpdate(state, awareness) {
10305	const currentStates = awareness.getStates();
10306	const added = /* @__PURE__ */ new Set();
10307	const updated = /* @__PURE__ */ new Set();
10308	const removed = new Set(
10309	Array.from(currentStates.keys()).filter(
10310	(clientId) => !state[clientId]
10311	)
10312	);
10313	Object.entries(state).forEach(([clientIdString, awarenessState]) => {
10314	const clientId = Number(clientIdString);
10315	if (clientId === awareness.clientID) {
10316	return;
10317	}
10318	if (null === awarenessState) {
10319	currentStates.delete(clientId);
10320	removed.add(clientId);
10321	return;
10322	}
10323	if (!currentStates.has(clientId)) {
10324	currentStates.set(clientId, awarenessState);
10325	added.add(clientId);
10326	return;
10327	}
10328	const currentState = currentStates.get(clientId);
10329	if (JSON.stringify(currentState) !== JSON.stringify(awarenessState)) {
10330	currentStates.set(clientId, awarenessState);
10331	updated.add(clientId);
10332	}
10333	});
10334	if (added.size + updated.size > 0) {
10335	awareness.emit("change", [
10336	{
10337	added: Array.from(added),
10338	updated: Array.from(updated),
10339	// Left blank on purpose, as the removal of clients is handled in the if condition below.
10340	removed: []
10341	}
10342	]);
10343	}
10344	if (removed.size > 0) {
10345	removeAwarenessStates(
10346	awareness,
10347	Array.from(removed),
10348	POLLING_MANAGER_ORIGIN
10349	);
10350	}
10351	}
10352	function processDocUpdate(update, doc2, onSync) {
10353	const data = base64ToUint8Array(update.data);
10354	switch (update.type) {
10355	case SyncUpdateType.SYNC_STEP_1: {
10356	return createSyncStep2Update(doc2, data);
10357	}
10358	case SyncUpdateType.SYNC_STEP_2: {
10359	const decoder = createDecoder(data);
10360	const encoder = createEncoder();
10361	readSyncMessage(
10362	decoder,
10363	encoder,
10364	doc2,
10365	POLLING_MANAGER_ORIGIN
10366	);
10367	onSync();
10368	return;
10369	}
10370	case SyncUpdateType.COMPACTION:
10371	case SyncUpdateType.UPDATE: {
10372	applyUpdateV2(doc2, data, POLLING_MANAGER_ORIGIN);
10373	}
10374	}
10375	}
10376	function checkConnectionLimit(awareness, roomState) {
10377	if (!roomState.isPrimaryRoom \|\| hasCheckedConnectionLimit) {
10378	return false;
10379	}
10380	hasCheckedConnectionLimit = true;
10381	const maxClientsPerRoom = (0, import_hooks2.applyFilters)(
10382	"sync.pollingProvider.maxClientsPerRoom",
10383	DEFAULT_CLIENT_LIMIT_PER_ROOM,
10384	roomState.room
10385	);
10386	const clientCount = Object.keys(awareness).length;
10387	const validatedLimit = intValueOrDefault(
10388	maxClientsPerRoom,
10389	DEFAULT_CLIENT_LIMIT_PER_ROOM
10390	);
10391	if (clientCount > validatedLimit) {
10392	roomState.log("Connection limit exceeded", {
10393	clientCount,
10394	maxClientsPerRoom: validatedLimit,
10395	room: roomState.room
10396	});
10397	return true;
10398	}
10399	return false;
10400	}
10401	var areListenersRegistered = false;
10402	var consecutiveFailures = 0;
10403	var hasCheckedConnectionLimit = false;
10404	var isManualRetry = false;
10405	var hasCollaborators = false;
10406	var isActiveBrowser = "visible" === document.visibilityState;
10407	var isPolling = false;
10408	var isUnloadPending = false;
10409	var pollInterval = POLLING_INTERVAL_IN_MS;
10410	var pollingTimeoutId = null;
10411	var syncRequestBodySizeLimit = MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES;
10412	var roomOverflowOffset = 0;
10413	function handleBeforeUnload() {
10414	isUnloadPending = true;
10415	}
10416	function handlePageHide() {
10417	const rooms = Array.from(roomStates.entries()).map(
10418	([room, state]) => ({
10419	after: 0,
10420	awareness: null,
10421	client_id: state.clientId,
10422	room,
10423	updates: []
10424	})
10425	);
10426	for (let i = 0; i < rooms.length; i += MAX_ROOMS_PER_REQUEST) {
10427	postSyncUpdateNonBlocking({
10428	rooms: rooms.slice(i, i + MAX_ROOMS_PER_REQUEST)
10429	});
10430	}
10431	}
10432	function handleVisibilityChange() {
10433	const wasActive = isActiveBrowser;
10434	isActiveBrowser = document.visibilityState === "visible";
10435	if (isActiveBrowser && !wasActive) {
10436	if (pollingTimeoutId) {
10437	clearTimeout(pollingTimeoutId);
10438	pollingTimeoutId = null;
10439	poll();
10440	}
10441	}
10442	}
10443	function selectRoomsForRequest() {
10444	const allRooms = Array.from(roomStates.values());
10445	if (allRooms.length <= MAX_ROOMS_PER_REQUEST) {
10446	return allRooms;
10447	}
10448	const primaryRoom = allRooms.find((state) => state.isPrimaryRoom);
10449	const overflowRooms = allRooms.filter((state) => state !== primaryRoom);
10450	const overflowSlotsPerRequest = MAX_ROOMS_PER_REQUEST - (primaryRoom ? 1 : 0);
10451	const { window: overflowSlice, nextOffset } = rotateWindow(
10452	overflowRooms,
10453	roomOverflowOffset,
10454	overflowSlotsPerRequest
10455	);
10456	roomOverflowOffset = nextOffset;
10457	if (primaryRoom) {
10458	return [primaryRoom, ...overflowSlice];
10459	}
10460	return overflowSlice;
10461	}
10462	var textEncoder = new TextEncoder();
10463	function getJsonByteLength(value) {
10464	return textEncoder.encode(JSON.stringify(value)).byteLength;
10465	}
10466	function createPayloadRoom(state, updates = []) {
10467	return {
10468	after: state.endCursor ?? 0,
10469	awareness: state.localAwarenessState,
10470	client_id: state.clientId,
10471	room: state.room,
10472	updates
10473	};
10474	}
10475	function getUpdatePayloadSizeDelta(existingUpdateCount, update) {
10476	const commaSize = existingUpdateCount === 0 ? 0 : 1;
10477	return commaSize + getJsonByteLength(update);
10478	}
10479	function buildPayloadForRequest(selectedRoomStates) {
10480	const payload = { rooms: [] };
10481	const roomsInRequest = [];
10482	for (const state of selectedRoomStates) {
10483	const room = createPayloadRoom(state);
10484	const candidate = { rooms: [...payload.rooms, room] };
10485	if (payload.rooms.length > 0 && getJsonByteLength(candidate) > syncRequestBodySizeLimit) {
10486	break;
10487	}
10488	payload.rooms.push(room);
10489	roomsInRequest.push(state);
10490	}
10491	const pendingUpdates = roomsInRequest.map(
10492	(state) => state.updateQueue.peek()
10493	);
10494	const sentUpdateCounts = roomsInRequest.map(() => 0);
10495	let payloadSize = getJsonByteLength(payload);
10496	let addedUpdate = true;
10497	while (addedUpdate) {
10498	addedUpdate = false;
10499	for (let i = 0; i < roomsInRequest.length; i++) {
10500	const update = pendingUpdates[i][sentUpdateCounts[i]];
10501	if (!update) {
10502	continue;
10503	}
10504	const sizeDelta = getUpdatePayloadSizeDelta(
10505	sentUpdateCounts[i],
10506	update
10507	);
10508	if (payloadSize + sizeDelta > syncRequestBodySizeLimit) {
10509	continue;
10510	}
10511	sentUpdateCounts[i]++;
10512	payloadSize += sizeDelta;
10513	addedUpdate = true;
10514	}
10515	}
10516	for (let i = 0; i < roomsInRequest.length; i++) {
10517	payload.rooms[i].updates = roomsInRequest[i].updateQueue.take(
10518	sentUpdateCounts[i]
10519	);
10520	}
10521	return { payload, roomsInRequest };
10522	}
10523	function restoreExactUpdates(payload) {
10524	for (const room of payload.rooms) {
10525	if (!roomStates.has(room.room) \|\| room.updates.length === 0) {
10526	continue;
10527	}
10528	roomStates.get(room.room).updateQueue.restoreExact(room.updates);
10529	}
10530	}
10531	function poll() {
10532	isPolling = true;
10533	pollingTimeoutId = null;
10534	async function start() {
10535	if (0 === roomStates.size) {
10536	isPolling = false;
10537	return;
10538	}
10539	isUnloadPending = false;
10540	const { payload, roomsInRequest } = buildPayloadForRequest(
10541	selectRoomsForRequest()
10542	);
10543	roomsInRequest.forEach((state) => {
10544	state.onStatusChange({ status: "connecting" });
10545	});
10546	try {
10547	const { rooms } = await postSyncUpdate(payload);
10548	consecutiveFailures = 0;
10549	isManualRetry = false;
10550	syncRequestBodySizeLimit = MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES;
10551	roomsInRequest.forEach((state) => {
10552	if (roomStates.get(state.room) !== state) {
10553	return;
10554	}
10555	state.onStatusChange({ status: "connected" });
10556	});
10557	hasCollaborators = false;
10558	rooms.forEach((room) => {
10559	if (!roomStates.has(room.room)) {
10560	return;
10561	}
10562	const roomState = roomStates.get(room.room);
10563	roomState.endCursor = room.end_cursor;
10564	if (checkConnectionLimit(room.awareness, roomState)) {
10565	roomState.onStatusChange({
10566	status: "disconnected",
10567	error: new ConnectionError(
10568	ConnectionErrorCode.CONNECTION_LIMIT_EXCEEDED,
10569	"Connection limit exceeded"
10570	)
10571	});
10572	unregisterRoom(room.room);
10573	return;
10574	}
10575	roomState.processAwarenessUpdate(room.awareness);
10576	if (roomState.isPrimaryRoom && Object.keys(room.awareness).length > 1) {
10577	hasCollaborators = true;
10578	roomStates.forEach((state) => {
10579	state.updateQueue.resume();
10580	});
10581	}
10582	const responseUpdates = [];
10583	for (const update of room.updates) {
10584	try {
10585	const response = roomState.processDocUpdate(update);
10586	if (response) {
10587	responseUpdates.push(response);
10588	}
10589	} catch (error) {
10590	roomState.log(
10591	"Failed to apply sync update",
10592	{ error, update },
10593	"error",
10594	true
10595	// force
10596	);
10597	}
10598	}
10599	roomState.updateQueue.addBulk(responseUpdates);
10600	if (room.should_compact) {
10601	roomState.log("Server requested compaction update");
10602	roomState.updateQueue.clear();
10603	roomState.updateQueue.add(
10604	roomState.createCompactionUpdate()
10605	);
10606	} else if (room.compaction_request) {
10607	roomState.log("Server requested (old) compaction update");
10608	roomState.updateQueue.add(
10609	createDeprecatedCompactionUpdate(
10610	room.compaction_request
10611	)
10612	);
10613	}
10614	});
10615	if (isActiveBrowser && hasCollaborators) {
10616	pollInterval = POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS;
10617	} else if (isActiveBrowser) {
10618	pollInterval = POLLING_INTERVAL_IN_MS;
10619	} else {
10620	pollInterval = POLLING_INTERVAL_BACKGROUND_TAB_IN_MS;
10621	}
10622	} catch (error) {
10623	if (isForbiddenError(error)) {
10624	handleForbiddenError(error, payload.rooms);
10625	if (roomStates.size === 0) {
10626	isPolling = false;
10627	return;
10628	}
10629	} else if (isRequestBodyTooLargeError(error)) {
10630	syncRequestBodySizeLimit = Math.max(
10631	MIN_SYNC_REQUEST_BODY_SIZE_LIMIT_IN_BYTES,
10632	Math.floor(syncRequestBodySizeLimit / 2)
10633	);
10634	pollInterval = hasCollaborators ? ERROR_RETRY_DELAYS_WITH_COLLABORATORS_MS[0] : ERROR_RETRY_DELAYS_SOLO_MS[0];
10635	restoreExactUpdates(payload);
10636	for (const room of payload.rooms) {
10637	if (!roomStates.has(room.room)) {
10638	continue;
10639	}
10640	roomStates.get(room.room).log(
10641	"Sync request body too large, retrying with smaller batches",
10642	{
10643	error,
10644	nextPoll: pollInterval,
10645	syncRequestBodySizeLimit
10646	},
10647	"error",
10648	true
10649	// force
10650	);
10651	}
10652	} else if (isProtocolMismatchError(error)) {
10653	const affectedRooms = [...roomStates.entries()];
10654	for (const [, state] of affectedRooms) {
10655	state.onStatusChange({
10656	status: "disconnected",
10657	error: new ConnectionError(
10658	ConnectionErrorCode.PROTOCOL_MISMATCH,
10659	"Protocol mismatch between client and server"
10660	)
10661	});
10662	}
10663	for (const [room] of affectedRooms) {
10664	unregisterRoom(room, { sendDisconnectSignal: false });
10665	}
10666	isPolling = false;
10667	return;
10668	} else {
10669	consecutiveFailures++;
10670	const retrySchedule = hasCollaborators ? ERROR_RETRY_DELAYS_WITH_COLLABORATORS_MS : ERROR_RETRY_DELAYS_SOLO_MS;
10671	if (consecutiveFailures <= retrySchedule.length) {
10672	pollInterval = retrySchedule[consecutiveFailures - 1];
10673	} else {
10674	pollInterval = DISCONNECT_DIALOG_RETRY_MS;
10675	}
10676	if (isManualRetry) {
10677	pollInterval = MANUAL_RETRY_INTERVAL_MS;
10678	isManualRetry = false;
10679	}
10680	for (const room of payload.rooms) {
10681	if (!roomStates.has(room.room)) {
10682	continue;
10683	}
10684	const state = roomStates.get(room.room);
10685	if (room.updates.length > 0 && state.endCursor > 0) {
10686	state.updateQueue.clear();
10687	state.updateQueue.add(state.createCompactionUpdate());
10688	} else if (room.updates.length > 0) {
10689	state.updateQueue.restore(room.updates);
10690	}
10691	state.log(
10692	"Error posting sync update, will retry with backoff",
10693	{ error, nextPoll: pollInterval },
10694	"error",
10695	true
10696	// force
10697	);
10698	}
10699	if (!isUnloadPending) {
10700	const backgroundRetriesFailed = consecutiveFailures > retrySchedule.length;
10701	roomsInRequest.forEach((state) => {
10702	if (roomStates.get(state.room) !== state) {
10703	return;
10704	}
10705	state.onStatusChange({
10706	status: "disconnected",
10707	canManuallyRetry: true,
10708	consecutiveFailures,
10709	backgroundRetriesFailed,
10710	willAutoRetryInMs: pollInterval
10711	});
10712	});
10713	}
10714	}
10715	}
10716	pollingTimeoutId = setTimeout(poll, pollInterval);
10717	}
10718	void start();
10719	}
10720	function registerRoom({
10721	room,
10722	doc: doc2,
10723	awareness,
10724	log,
10725	onSync,
10726	onStatusChange
10727	}) {
10728	if (roomStates.has(room)) {
10729	return;
10730	}
10731	const updateQueue = createUpdateQueue([createSyncStep1Update(doc2)]);
10732	const isPrimaryRoom = 0 === roomStates.size;
10733	function onAwarenessUpdate() {
10734	roomState.localAwarenessState = awareness.getLocalState() ?? {};
10735	}
10736	function onDocUpdate(update, origin2) {
10737	if (POLLING_MANAGER_ORIGIN === origin2) {
10738	return;
10739	}
10740	if (update.byteLength > MAX_UPDATE_SIZE_IN_BYTES) {
10741	const state = roomStates.get(room);
10742	if (!state) {
10743	return;
10744	}
10745	state.log("Document size limit exceeded", {
10746	maxUpdateSizeInBytes: MAX_UPDATE_SIZE_IN_BYTES,
10747	updateSizeInBytes: update.byteLength
10748	});
10749	state.onStatusChange({
10750	status: "disconnected",
10751	error: new ConnectionError(
10752	ConnectionErrorCode.DOCUMENT_SIZE_LIMIT_EXCEEDED,
10753	"Document size limit exceeded"
10754	)
10755	});
10756	unregisterRoom(room);
10757	return;
10758	}
10759	updateQueue.add(createSyncUpdate(update, SyncUpdateType.UPDATE));
10760	}
10761	function unregister() {
10762	doc2.off("updateV2", onDocUpdate);
10763	awareness.off("change", onAwarenessUpdate);
10764	updateQueue.clear();
10765	}
10766	const roomState = {
10767	clientId: doc2.clientID,
10768	createCompactionUpdate: () => createSyncUpdate(
10769	encodeStateAsUpdateV2(doc2),
10770	SyncUpdateType.COMPACTION
10771	),
10772	endCursor: 0,
10773	isPrimaryRoom,
10774	localAwarenessState: awareness.getLocalState() ?? {},
10775	log,
10776	onStatusChange,
10777	processAwarenessUpdate: (state) => processAwarenessUpdate(state, awareness),
10778	processDocUpdate: (update) => processDocUpdate(update, doc2, onSync),
10779	room,
10780	unregister,
10781	updateQueue
10782	};
10783	doc2.on("updateV2", onDocUpdate);
10784	awareness.on("change", onAwarenessUpdate);
10785	roomStates.set(room, roomState);
10786	if (!areListenersRegistered) {
10787	window.addEventListener("beforeunload", handleBeforeUnload);
10788	window.addEventListener("pagehide", handlePageHide);
10789	document.addEventListener("visibilitychange", handleVisibilityChange);
10790	areListenersRegistered = true;
10791	}
10792	if (!isPolling) {
10793	poll();
10794	}
10795	}
10796	function unregisterRoom(room, { sendDisconnectSignal = true } = {}) {
10797	const state = roomStates.get(room);
10798	if (state) {
10799	if (sendDisconnectSignal) {
10800	const rooms = [
10801	{
10802	after: 0,
10803	awareness: null,
10804	client_id: state.clientId,
10805	room,
10806	updates: []
10807	}
10808	];
10809	postSyncUpdateNonBlocking({ rooms });
10810	}
10811	state.unregister();
10812	roomStates.delete(room);
10813	}
10814	if (0 === roomStates.size && areListenersRegistered) {
10815	window.removeEventListener("beforeunload", handleBeforeUnload);
10816	window.removeEventListener("pagehide", handlePageHide);
10817	document.removeEventListener(
10818	"visibilitychange",
10819	handleVisibilityChange
10820	);
10821	areListenersRegistered = false;
10822	hasCheckedConnectionLimit = false;
10823	consecutiveFailures = 0;
10824	roomOverflowOffset = 0;
10825	syncRequestBodySizeLimit = MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES;
10826	}
10827	}
10828	function retryNow() {
10829	isManualRetry = true;
10830	if (pollingTimeoutId) {
10831	clearTimeout(pollingTimeoutId);
10832	pollingTimeoutId = null;
10833	poll();
10834	}
10835	}
10836	var pollingManager = {
10837	registerRoom,
10838	retryNow,
10839	unregisterRoom
10840	};
10841
10842	// packages/sync/build-module/providers/http-polling/http-polling-provider.mjs
10843	var HttpPollingProvider = class extends ObservableV2 {
10844	constructor(options) {
10845	super();
10846	this.options = options;
10847	this.log("Initializing", { room: options.room });
10848	this.awareness = options.awareness ?? new Awareness(options.ydoc);
10849	this.connect();
10850	}
10851	awareness;
10852	status = "disconnected";
10853	synced = false;
10854	/**
10855	* Connect to the endpoint and initialize sync.
10856	*/
10857	connect() {
10858	this.log("Connecting");
10859	pollingManager.registerRoom({
10860	room: this.options.room,
10861	doc: this.options.ydoc,
10862	awareness: this.awareness,
10863	log: this.log,
10864	onStatusChange: this.emitStatus,
10865	onSync: this.onSync
10866	});
10867	}
10868	/**
10869	* Destroy the provider and cleanup resources.
10870	*/
10871	destroy() {
10872	this.disconnect();
10873	super.destroy();
10874	}
10875	/**
10876	* Disconnect the provider and allow reconnection later.
10877	*/
10878	disconnect() {
10879	this.log("Disconnecting");
10880	pollingManager.unregisterRoom(this.options.room);
10881	this.emitStatus({ status: "disconnected" });
10882	}
10883	/**
10884	* Emit connection status, passing the full object through so that
10885	* additional fields (e.g. `willAutoRetryInMs`) are preserved for consumers.
10886	*
10887	* @param connectionStatus The connection status object
10888	*/
10889	emitStatus = (connectionStatus) => {
10890	const { status } = connectionStatus;
10891	const error = status === "disconnected" ? connectionStatus.error : void 0;
10892	if (this.status === status && !error) {
10893	return;
10894	}
10895	if (status === "connecting" && this.status !== "disconnected") {
10896	return;
10897	}
10898	this.log("Status change", { status, error });
10899	this.status = status;
10900	this.emit("status", [connectionStatus]);
10901	};
10902	/**
10903	* Log debug messages if debugging is enabled.
10904	*
10905	* @param message The debug message
10906	* @param debug Additional debug information
10907	* @param errorLevel The console method to use for logging
10908	* @param force Whether to force logging regardless of debug setting
10909	*/
10910	log = (message, debug = {}, errorLevel = "log", force = false) => {
10911	if (!this.options.debug && !force) {
10912	return;
10913	}
10914	const logFn = console[errorLevel] \|\| console.log;
10915	logFn(`[${this.constructor.name}]: ${message}`, {
10916	room: this.options.room,
10917	...debug
10918	});
10919	};
10920	/**
10921	* Handle synchronization events from the polling manager.
10922	*/
10923	onSync = () => {
10924	if (!this.synced) {
10925	this.synced = true;
10926	this.log("Synced");
10927	}
10928	};
10929	};
10930	function createHttpPollingProvider() {
10931	return async ({
10932	awareness,
10933	objectType,
10934	objectId,
10935	ydoc
10936	}) => {
10937	const room = objectId ? `${objectType}:${objectId}` : objectType;
10938	const provider = new HttpPollingProvider({
10939	awareness,
10940	// debug: true,
10941	room,
10942	ydoc
10943	});
10944	return {
10945	destroy: () => provider.destroy(),
10946	// Adapter: ObservableV2.on is compatible with ProviderOn
10947	// The callback receives data as the first parameter
10948	on: (event, callback) => {
10949	provider.on(event, callback);
10950	}
10951	};
10952	};
10953	}
10954
10955	// packages/sync/build-module/providers/index.mjs
10956	var providerCreators = null;
10957	function getDefaultProviderCreators() {
10958	return [createHttpPollingProvider()];
10959	}
10960	function isProviderCreator(creator) {
10961	return "function" === typeof creator;
10962	}
10963	function getProviderCreators() {
10964	if (providerCreators) {
10965	return providerCreators;
10966	}
10967	if (!window._wpCollaborationEnabled) {
10968	return [];
10969	}
10970	const filteredProviderCreators = (0, import_hooks3.applyFilters)(
10971	"sync.providers",
10972	getDefaultProviderCreators()
10973	);
10974	if (!Array.isArray(filteredProviderCreators)) {
10975	providerCreators = [];
10976	return providerCreators;
10977	}
10978	providerCreators = filteredProviderCreators.filter(isProviderCreator);
10979	return providerCreators;
10980	}
10981
10982	// packages/sync/build-module/y-utilities/y-multidoc-undomanager.mjs
10983	var popStackItem2 = (mum, type) => {
10984	const stack = type === "undo" ? mum.undoStack : mum.redoStack;
10985	while (stack.length > 0) {
10986	const um = (
10987	/** @type {Y.UndoManager} */
10988	stack.pop()
10989	);
10990	const prevUmStack = type === "undo" ? um.undoStack : um.redoStack;
10991	const stackItem = (
10992	/** @type {any} */
10993	prevUmStack.pop()
10994	);
10995	let actionPerformed = false;
10996	if (type === "undo") {
10997	um.undoStack = [stackItem];
10998	actionPerformed = um.undo() !== null;
10999	um.undoStack = prevUmStack;
11000	} else {
11001	um.redoStack = [stackItem];
11002	actionPerformed = um.redo() !== null;
11003	um.redoStack = prevUmStack;
11004	}
11005	if (actionPerformed) {
11006	return stackItem;
11007	}
11008	}
11009	return null;
11010	};
11011	var YMultiDocUndoManager = class extends Observable {
11012	/**
11013	* @param {Y.AbstractType<any>\|Array<Y.AbstractType<any>>} typeScope Accepts either a single type, or an array of types
11014	* @param {ConstructorParameters<typeof Y.UndoManager>[1]} opts
11015	*/
11016	constructor(typeScope = [], opts = {}) {
11017	super();
11018	this.docs = /* @__PURE__ */ new Map();
11019	this.trackedOrigins = opts.trackedOrigins \|\| /* @__PURE__ */ new Set([null]);
11020	opts.trackedOrigins = this.trackedOrigins;
11021	this._defaultOpts = opts;
11022	this.undoStack = [];
11023	this.redoStack = [];
11024	this.addToScope(typeScope);
11025	}
11026	/**
11027	* @param {Array<Y.AbstractType<any>> \| Y.AbstractType<any>} ytypes
11028	*/
11029	addToScope(ytypes) {
11030	ytypes = isArray(ytypes) ? ytypes : [ytypes];
11031	ytypes.forEach((ytype) => {
11032	const ydoc = (
11033	/** @type {Y.Doc} */
11034	ytype.doc
11035	);
11036	const um = setIfUndefined(this.docs, ydoc, () => {
11037	const um2 = new UndoManager([ytype], this._defaultOpts);
11038	um2.on(
11039	"stack-cleared",
11040	/** @param {any} opts */
11041	({
11042	undoStackCleared,
11043	redoStackCleared
11044	}) => {
11045	this.clear(undoStackCleared, redoStackCleared);
11046	}
11047	);
11048	ydoc.on("destroy", () => {
11049	this.docs.delete(ydoc);
11050	this.undoStack = this.undoStack.filter(
11051	(um3) => um3.doc !== ydoc
11052	);
11053	this.redoStack = this.redoStack.filter(
11054	(um3) => um3.doc !== ydoc
11055	);
11056	});
11057	um2.on(
11058	"stack-item-added",
11059	/** @param {any} change */
11060	(change) => {
11061	const stack = change.type === "undo" ? this.undoStack : this.redoStack;
11062	stack.push(um2);
11063	this.emit("stack-item-added", [
11064	{ ...change, ydoc },
11065	this
11066	]);
11067	}
11068	);
11069	um2.on(
11070	"stack-item-updated",
11071	/** @param {any} change */
11072	(change) => {
11073	this.emit("stack-item-updated", [
11074	{ ...change, ydoc },
11075	this
11076	]);
11077	}
11078	);
11079	um2.on(
11080	"stack-item-popped",
11081	/** @param {any} change */
11082	(change) => {
11083	this.emit("stack-item-popped", [
11084	{ ...change, ydoc },
11085	this
11086	]);
11087	}
11088	);
11089	return um2;
11090	});
11091	if (um.scope.every((yt) => yt !== ytype)) {
11092	um.scope.push(ytype);
11093	}
11094	});
11095	}
11096	/**
11097	* @param {any} origin
11098	*/
11099	/* c8 ignore next 3 */
11100	addTrackedOrigin(origin2) {
11101	this.trackedOrigins.add(origin2);
11102	}
11103	/**
11104	* @param {any} origin
11105	*/
11106	/* c8 ignore next 3 */
11107	removeTrackedOrigin(origin2) {
11108	this.trackedOrigins.delete(origin2);
11109	}
11110	/**
11111	* Undo last changes on type.
11112	*
11113	* @return {any?} Returns StackItem if a change was applied
11114	*/
11115	undo() {
11116	return popStackItem2(this, "undo");
11117	}
11118	/**
11119	* Redo last undo operation.
11120	*
11121	* @return {any?} Returns StackItem if a change was applied
11122	*/
11123	redo() {
11124	return popStackItem2(this, "redo");
11125	}
11126	clear(clearUndoStack = true, clearRedoStack = true) {
11127	if (clearUndoStack && this.canUndo() \|\| clearRedoStack && this.canRedo()) {
11128	this.docs.forEach((um) => {
11129	clearUndoStack && (this.undoStack = []);
11130	clearRedoStack && (this.redoStack = []);
11131	um.clear(clearUndoStack, clearRedoStack);
11132	});
11133	this.emit("stack-cleared", [
11134	{
11135	undoStackCleared: clearUndoStack,
11136	redoStackCleared: clearRedoStack
11137	}
11138	]);
11139	}
11140	}
11141	/* c8 ignore next 5 */
11142	stopCapturing() {
11143	this.docs.forEach((um) => {
11144	um.stopCapturing();
11145	});
11146	}
11147	/**
11148	* Are undo steps available?
11149	*
11150	* @return {boolean} `true` if undo is possible
11151	*/
11152	canUndo() {
11153	return this.undoStack.length > 0;
11154	}
11155	/**
11156	* Are redo steps available?
11157	*
11158	* @return {boolean} `true` if redo is possible
11159	*/
11160	canRedo() {
11161	return this.redoStack.length > 0;
11162	}
11163	destroy() {
11164	this.docs.forEach((um) => um.destroy());
11165	super.destroy();
11166	}
11167	};
11168
11169	// packages/sync/build-module/undo-manager.mjs
11170	function createUndoManager() {
11171	const undoMetaHandlers = /* @__PURE__ */ new Map();
11172	const yUndoManager = new YMultiDocUndoManager([], {
11173	// Throttle undo/redo captures after 500ms of inactivity.
11174	// 500 was selected from subjective local UX testing, shorter timeouts
11175	// may cause mid-word undo stack items.
11176	captureTimeout: 500,
11177	// Ensure that we only scope the undo/redo to the current editor.
11178	// The yjs document's clientID is added once it's available.
11179	trackedOrigins: /* @__PURE__ */ new Set([LOCAL_EDITOR_ORIGIN])
11180	});
11181	const getUndoStackState = () => ({
11182	hasRedo: yUndoManager.canRedo(),
11183	hasUndo: yUndoManager.canUndo()
11184	});
11185	const notifyUndoStackChange = (ydoc) => {
11186	undoMetaHandlers.get(ydoc)?.onUndoStackChange?.(getUndoStackState());
11187	};
11188	yUndoManager.on("stack-item-added", (event) => {
11189	const handlers = undoMetaHandlers.get(event.ydoc);
11190	if (!handlers) {
11191	return;
11192	}
11193	handlers.addUndoMeta(event.ydoc, event.stackItem.meta);
11194	notifyUndoStackChange(event.ydoc);
11195	});
11196	yUndoManager.on("stack-item-updated", (event) => {
11197	notifyUndoStackChange(event.ydoc);
11198	});
11199	yUndoManager.on("stack-item-popped", (event) => {
11200	const handlers = undoMetaHandlers.get(event.ydoc);
11201	if (!handlers) {
11202	return;
11203	}
11204	handlers.restoreUndoMeta(event.ydoc, event.stackItem.meta);
11205	notifyUndoStackChange(event.ydoc);
11206	});
11207	yUndoManager.on("stack-cleared", () => {
11208	undoMetaHandlers.forEach((handlers) => {
11209	handlers.onUndoStackChange?.(getUndoStackState());
11210	});
11211	});
11212	return {
11213	/**
11214	* Record changes into the history.
11215	* Since Yjs automatically tracks changes, this method translates the WordPress
11216	* HistoryRecord format into Yjs operations.
11217	*
11218	* @param _record A record of changes to record.
11219	* @param _isStaged Whether to immediately create an undo point or not.
11220	*/
11221	addRecord(_record, _isStaged = false) {
11222	},
11223	/**
11224	* Add a Yjs map to the scope of the undo manager.
11225	*
11226	* @param {Y.Map< any >} ymap The Yjs map to add to the scope.
11227	* @param handlers Handlers for the scoped document.
11228	* @param handlers.addUndoMeta Handler to add metadata to undo items.
11229	* @param handlers.onUndoStackChange Handler for undo stack changes.
11230	* @param handlers.restoreUndoMeta Handler to restore metadata from undo items.
11231	*/
11232	addToScope(ymap, handlers) {
11233	if (ymap.doc === null) {
11234	return;
11235	}
11236	const ydoc = ymap.doc;
11237	yUndoManager.addToScope(ymap);
11238	if (!undoMetaHandlers.has(ydoc)) {
11239	ydoc.on("destroy", () => undoMetaHandlers.delete(ydoc));
11240	}
11241	undoMetaHandlers.set(ydoc, handlers);
11242	},
11243	/**
11244	* Undo the last recorded changes.
11245	*
11246	*/
11247	undo() {
11248	if (!yUndoManager.canUndo()) {
11249	return;
11250	}
11251	yUndoManager.undo();
11252	return [];
11253	},
11254	/**
11255	* Redo the last undone changes.
11256	*/
11257	redo() {
11258	if (!yUndoManager.canRedo()) {
11259	return;
11260	}
11261	yUndoManager.redo();
11262	return [];
11263	},
11264	/**
11265	* Check if there are changes that can be undone.
11266	*
11267	* @return {boolean} Whether there are changes to undo.
11268	*/
11269	hasUndo() {
11270	return yUndoManager.canUndo();
11271	},
11272	/**
11273	* Check if there are changes that can be redone.
11274	*
11275	* @return {boolean} Whether there are changes to redo.
11276	*/
11277	hasRedo() {
11278	return yUndoManager.canRedo();
11279	},
11280	/**
11281	* Stop capturing changes into the current undo item.
11282	* The next change will create a new undo item.
11283	*/
11284	stopCapturing() {
11285	yUndoManager.stopCapturing();
11286	}
11287	};
11288	}
11289
11290	// packages/sync/build-module/utils.mjs
11291	function createYjsDoc(documentMeta = {}) {
11292	const metaMap = new Map(
11293	Object.entries(documentMeta)
11294	);
11295	return new Doc({ meta: metaMap });
11296	}
11297	function initializeYjsDoc(ydoc) {
11298	const stateMap = ydoc.getMap(CRDT_STATE_MAP_KEY);
11299	stateMap.set(CRDT_STATE_MAP_VERSION_KEY, CRDT_DOC_VERSION);
11300	}
11301	function markEntityAsSaved(ydoc) {
11302	const recordMeta = ydoc.getMap(CRDT_STATE_MAP_KEY);
11303	recordMeta.set(CRDT_STATE_MAP_SAVED_AT_KEY, Date.now());
11304	recordMeta.set(CRDT_STATE_MAP_SAVED_BY_KEY, ydoc.clientID);
11305	}
11306	function pseudoRandomID() {
11307	return Math.floor(Math.random() * 1e9);
11308	}
11309	function serializeCrdtDoc(crdtDoc) {
11310	return JSON.stringify({
11311	document: toBase64(encodeStateAsUpdateV2(crdtDoc)),
11312	updateId: pseudoRandomID()
11313	// helps with debugging
11314	});
11315	}
11316	function deserializeCrdtDoc(serializedCrdtDoc) {
11317	try {
11318	const { document: document2 } = JSON.parse(serializedCrdtDoc);
11319	const docMeta = {
11320	[CRDT_DOC_META_PERSISTENCE_KEY]: true
11321	};
11322	const ydoc = createYjsDoc(docMeta);
11323	const yupdate = fromBase64(document2);
11324	applyUpdateV2(ydoc, yupdate);
11325	ydoc.clientID = pseudoRandomID();
11326	return ydoc;
11327	} catch {
11328	return null;
11329	}
11330	}
11331
11332	// packages/sync/build-module/manager.mjs
11333	function getEntityId(objectType, objectId) {
11334	return `${objectType}_${objectId}`;
11335	}
11336	function createSyncManager(debug = false) {
11337	const debugWrap = debug ? logPerformanceTiming : passThru;
11338	const collectionStates = /* @__PURE__ */ new Map();
11339	const entityStates = /* @__PURE__ */ new Map();
11340	let undoManager;
11341	function log(component, message, entityId, context = {}) {
11342	if (!debug) {
11343	return;
11344	}
11345	console.log(`[SyncManager][${component}]: ${message}`, {
11346	...context,
11347	entityId
11348	});
11349	}
11350	async function loadEntity(syncConfig, objectType, objectId, record, handlers) {
11351	const providerCreators2 = getProviderCreators();
11352	const entityId = getEntityId(objectType, objectId);
11353	if (0 === providerCreators2.length) {
11354	log("loadEntity", "no providers, skipping", entityId);
11355	return;
11356	}
11357	if (entityStates.has(entityId)) {
11358	log("loadEntity", "already loaded", entityId);
11359	return;
11360	}
11361	if (false === syncConfig.shouldSync?.(objectType, objectId)) {
11362	log("loadEntity", "shouldSync false, skipping", entityId);
11363	return;
11364	}
11365	log("loadEntity", "loading", entityId);
11366	handlers = {
11367	addUndoMeta: debugWrap(handlers.addUndoMeta),
11368	editRecord: debugWrap(handlers.editRecord),
11369	getEditedRecord: debugWrap(handlers.getEditedRecord),
11370	onStatusChange: debugWrap(handlers.onStatusChange),
11371	persistCRDTDoc: debugWrap(handlers.persistCRDTDoc),
11372	refetchRecord: debugWrap(handlers.refetchRecord),
11373	restoreUndoMeta: debugWrap(handlers.restoreUndoMeta),
11374	onUndoStackChange: handlers.onUndoStackChange ? debugWrap(handlers.onUndoStackChange) : void 0
11375	};
11376	const ydoc = createYjsDoc({ objectType });
11377	const recordMap = ydoc.getMap(CRDT_RECORD_MAP_KEY);
11378	const stateMap = ydoc.getMap(CRDT_STATE_MAP_KEY);
11379	const now = Date.now();
11380	let hasObserversAttached = false;
11381	let isEntityUnloaded = false;
11382	const unload = () => {
11383	log("loadEntity", "unloading", entityId);
11384	isEntityUnloaded = true;
11385	providerResults?.forEach((result) => result.destroy());
11386	handlers.onStatusChange(null);
11387	if (hasObserversAttached) {
11388	recordMap.unobserveDeep(onRecordUpdate);
11389	stateMap.unobserve(onStateMapUpdate);
11390	}
11391	ydoc.destroy();
11392	entityStates.delete(entityId);
11393	};
11394	const awareness = syncConfig.createAwareness?.(ydoc, objectId);
11395	const onRecordUpdate = (_events, transaction) => {
11396	if (transaction.local && !(transaction.origin instanceof UndoManager)) {
11397	return;
11398	}
11399	void internal.updateEntityRecord(objectType, objectId);
11400	};
11401	const onStateMapUpdate = (event, transaction) => {
11402	if (transaction.local) {
11403	return;
11404	}
11405	event.keysChanged.forEach((key) => {
11406	switch (key) {
11407	case CRDT_STATE_MAP_SAVED_AT_KEY:
11408	const savedAt = stateMap.get(CRDT_STATE_MAP_SAVED_AT_KEY);
11409	if ("number" === typeof savedAt && savedAt > now) {
11410	log("loadEntity", "refetching record", entityId);
11411	void handlers.refetchRecord().catch(() => {
11412	});
11413	}
11414	break;
11415	}
11416	});
11417	};
11418	if (!undoManager) {
11419	undoManager = createUndoManager();
11420	}
11421	const { addUndoMeta, onUndoStackChange, restoreUndoMeta } = handlers;
11422	undoManager.addToScope(recordMap, {
11423	addUndoMeta,
11424	restoreUndoMeta,
11425	onUndoStackChange
11426	});
11427	let providerResults;
11428	const entityState = {
11429	awareness,
11430	handlers,
11431	objectId,
11432	objectType,
11433	syncConfig,
11434	unload,
11435	ydoc
11436	};
11437	entityStates.set(entityId, entityState);
11438	log("loadEntity", "connecting", entityId);
11439	providerResults = await Promise.all(
11440	providerCreators2.map(async (create7) => {
11441	const provider = await create7({
11442	objectType,
11443	objectId,
11444	ydoc,
11445	awareness
11446	});
11447	provider.on("status", handlers.onStatusChange);
11448	return provider;
11449	})
11450	);
11451	if (isEntityUnloaded) {
11452	log("loadEntity", "unloaded during connect, aborting", entityId);
11453	providerResults.forEach((result) => result.destroy());
11454	return;
11455	}
11456	initializeYjsDoc(ydoc);
11457	internal.applyPersistedCrdtDoc(objectType, objectId, record);
11458	recordMap.observeDeep(onRecordUpdate);
11459	stateMap.observe(onStateMapUpdate);
11460	hasObserversAttached = true;
11461	}
11462	async function loadCollection(syncConfig, objectType, handlers) {
11463	const providerCreators2 = getProviderCreators();
11464	const entityId = getEntityId(objectType, null);
11465	if (0 === providerCreators2.length) {
11466	log("loadCollection", "no providers, skipping", entityId);
11467	return;
11468	}
11469	if (collectionStates.has(objectType)) {
11470	log("loadCollection", "already loaded", entityId);
11471	return;
11472	}
11473	if (false === syncConfig.shouldSync?.(objectType, null)) {
11474	log("loadCollection", "shouldSync false, skipping", entityId);
11475	return;
11476	}
11477	log("loadCollection", "loading", entityId);
11478	const ydoc = createYjsDoc({ collection: true, objectType });
11479	const stateMap = ydoc.getMap(CRDT_STATE_MAP_KEY);
11480	const now = Date.now();
11481	let hasObserversAttached = false;
11482	let isCollectionUnloaded = false;
11483	const unload = () => {
11484	log("loadCollection", "unloading", entityId);
11485	isCollectionUnloaded = true;
11486	providerResults?.forEach((result) => result.destroy());
11487	handlers.onStatusChange(null);
11488	if (hasObserversAttached) {
11489	stateMap.unobserve(onStateMapUpdate);
11490	}
11491	ydoc.destroy();
11492	collectionStates.delete(objectType);
11493	};
11494	const onStateMapUpdate = (event, transaction) => {
11495	if (transaction.local) {
11496	return;
11497	}
11498	event.keysChanged.forEach((key) => {
11499	switch (key) {
11500	case CRDT_STATE_MAP_SAVED_AT_KEY:
11501	const newValue = stateMap.get(CRDT_STATE_MAP_SAVED_AT_KEY);
11502	if ("number" === typeof newValue && newValue > now) {
11503	void handlers.refetchRecords().catch(() => {
11504	});
11505	}
11506	break;
11507	}
11508	});
11509	};
11510	const awareness = syncConfig.createAwareness?.(ydoc);
11511	let providerResults;
11512	const collectionState = {
11513	awareness,
11514	handlers,
11515	syncConfig,
11516	unload,
11517	ydoc
11518	};
11519	collectionStates.set(objectType, collectionState);
11520	log("loadCollection", "connecting", entityId);
11521	providerResults = await Promise.all(
11522	providerCreators2.map(async (create7) => {
11523	const provider = await create7({
11524	awareness,
11525	objectType,
11526	objectId: null,
11527	ydoc
11528	});
11529	provider.on("status", handlers.onStatusChange);
11530	return provider;
11531	})
11532	);
11533	if (isCollectionUnloaded) {
11534	log(
11535	"loadCollection",
11536	"unloaded during connect, aborting",
11537	entityId
11538	);
11539	providerResults.forEach((result) => result.destroy());
11540	return;
11541	}
11542	stateMap.observe(onStateMapUpdate);
11543	hasObserversAttached = true;
11544	initializeYjsDoc(ydoc);
11545	}
11546	function unloadEntity(objectType, objectId) {
11547	const entityId = getEntityId(objectType, objectId);
11548	log("unloadEntity", "unloading", entityId);
11549	entityStates.get(entityId)?.unload();
11550	updateCRDTDoc(objectType, null, {}, origin, {
11551	isSave: true
11552	});
11553	}
11554	function unloadAll() {
11555	log("unloadAll", "unloading all entities", "all");
11556	for (const [, entityState] of [...entityStates]) {
11557	entityState.unload();
11558	}
11559	entityStates.clear();
11560	undoManager = void 0;
11561	for (const [, collectionState] of [...collectionStates]) {
11562	collectionState.unload();
11563	}
11564	collectionStates.clear();
11565	}
11566	function getAwareness(objectType, objectId) {
11567	const entityId = getEntityId(objectType, objectId);
11568	const entityState = entityStates.get(entityId);
11569	if (!entityState \|\| !entityState.awareness) {
11570	return void 0;
11571	}
11572	return entityState.awareness;
11573	}
11574	function _applyPersistedCrdtDoc(objectType, objectId, record) {
11575	const entityId = getEntityId(objectType, objectId);
11576	const entityState = entityStates.get(entityId);
11577	if (!entityState) {
11578	log("applyPersistedCrdtDoc", "no entity state", entityId);
11579	return;
11580	}
11581	const {
11582	handlers,
11583	syncConfig: {
11584	applyChangesToCRDTDoc,
11585	getChangesFromCRDTDoc,
11586	getPersistedCRDTDoc
11587	},
11588	ydoc: targetDoc
11589	} = entityState;
11590	const serialized = getPersistedCRDTDoc?.(record);
11591	const tempDoc = serialized ? deserializeCrdtDoc(serialized) : null;
11592	if (!tempDoc) {
11593	log("applyPersistedCrdtDoc", "no persisted doc", entityId);
11594	targetDoc.transact(() => {
11595	applyChangesToCRDTDoc(targetDoc, record);
11596	handlers.persistCRDTDoc();
11597	}, LOCAL_SYNC_MANAGER_ORIGIN);
11598	return;
11599	}
11600	const update = encodeStateAsUpdateV2(tempDoc);
11601	applyUpdateV2(targetDoc, update);
11602	const invalidations = getChangesFromCRDTDoc(tempDoc, record);
11603	const invalidatedKeys = Object.keys(invalidations);
11604	tempDoc.destroy();
11605	if (0 === invalidatedKeys.length) {
11606	log("applyPersistedCrdtDoc", "valid persisted doc", entityId);
11607	return;
11608	}
11609	log("applyPersistedCrdtDoc", "invalidated keys", entityId, {
11610	invalidatedKeys
11611	});
11612	const changes = invalidatedKeys.reduce(
11613	(acc, key) => Object.assign(acc, {
11614	[key]: record[key]
11615	}),
11616	{}
11617	);
11618	targetDoc.transact(() => {
11619	applyChangesToCRDTDoc(targetDoc, changes);
11620	handlers.persistCRDTDoc();
11621	}, LOCAL_SYNC_MANAGER_ORIGIN);
11622	}
11623	function updateCRDTDoc(objectType, objectId, changes, origin2, options = {}) {
11624	const { isSave = false, isNewUndoLevel = false } = options;
11625	const entityId = getEntityId(objectType, objectId);
11626	const entityState = entityStates.get(entityId);
11627	const collectionState = collectionStates.get(objectType);
11628	if (entityState) {
11629	const { syncConfig, ydoc } = entityState;
11630	if (isNewUndoLevel && undoManager) {
11631	undoManager.stopCapturing?.();
11632	}
11633	ydoc.transact(() => {
11634	log("updateCRDTDoc", "applying changes", entityId, {
11635	changedKeys: Object.keys(changes)
11636	});
11637	syncConfig.applyChangesToCRDTDoc(ydoc, changes);
11638	if (isSave) {
11639	markEntityAsSaved(ydoc);
11640	}
11641	}, origin2);
11642	}
11643	if (collectionState && isSave) {
11644	collectionState.ydoc.transact(() => {
11645	markEntityAsSaved(collectionState.ydoc);
11646	}, origin2);
11647	}
11648	}
11649	const deferUpdateCRDTDoc = yieldToEventLoop(updateCRDTDoc);
11650	function updateOrDefer(objectType, objectId, changes, origin2, options = {}) {
11651	const hasRemotePeers = (getAwareness(objectType, objectId)?.getStates().size ?? 0) > 1;
11652	const update = hasRemotePeers ? updateCRDTDoc : deferUpdateCRDTDoc;
11653	update(objectType, objectId, changes, origin2, options);
11654	}
11655	async function _updateEntityRecord(objectType, objectId) {
11656	const entityId = getEntityId(objectType, objectId);
11657	const entityState = entityStates.get(entityId);
11658	if (!entityState) {
11659	log("updateEntityRecord", "no entity state", entityId);
11660	return;
11661	}
11662	const { handlers, syncConfig, ydoc } = entityState;
11663	const changes = syncConfig.getChangesFromCRDTDoc(
11664	ydoc,
11665	await handlers.getEditedRecord()
11666	);
11667	const changedKeys = Object.keys(changes);
11668	if (0 === changedKeys.length) {
11669	return;
11670	}
11671	log("updateEntityRecord", "changes", entityId, {
11672	changedKeys
11673	});
11674	handlers.editRecord(changes);
11675	}
11676	async function createPersistedCRDTDoc(objectType, objectId) {
11677	const entityId = getEntityId(objectType, objectId);
11678	const entityState = entityStates.get(entityId);
11679	if (!entityState?.ydoc) {
11680	return null;
11681	}
11682	await new Promise((resolve) => setTimeout(resolve, 0));
11683	return serializeCrdtDoc(entityState.ydoc);
11684	}
11685	const internal = {
11686	applyPersistedCrdtDoc: debugWrap(_applyPersistedCrdtDoc),
11687	updateEntityRecord: debugWrap(_updateEntityRecord)
11688	};
11689	return {
11690	createPersistedCRDTDoc: debugWrap(createPersistedCRDTDoc),
11691	getAwareness,
11692	load: debugWrap(loadEntity),
11693	loadCollection: debugWrap(loadCollection),
11694	// Use getter to ensure we always return the current value of `undoManager`.
11695	get undoManager() {
11696	return undoManager;
11697	},
11698	unload: debugWrap(unloadEntity),
11699	unloadAll: debugWrap(unloadAll),
11700	update: debugWrap(updateOrDefer)
11701	};
11702	}
11703
11704	// node_modules/diff/libesm/diff/base.js
11705	var Diff = class {
11706	diff(oldStr, newStr, options = {}) {
11707	let callback;
11708	if (typeof options === "function") {
11709	callback = options;
11710	options = {};
11711	} else if ("callback" in options) {
11712	callback = options.callback;
11713	}
11714	const oldString = this.castInput(oldStr, options);
11715	const newString = this.castInput(newStr, options);
11716	const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
11717	const newTokens = this.removeEmpty(this.tokenize(newString, options));
11718	return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
11719	}
11720	diffWithOptionsObj(oldTokens, newTokens, options, callback) {
11721	var _a;
11722	const done = (value) => {
11723	value = this.postProcess(value, options);
11724	if (callback) {
11725	setTimeout(function() {
11726	callback(value);
11727	}, 0);
11728	return void 0;
11729	} else {
11730	return value;
11731	}
11732	};
11733	const newLen = newTokens.length, oldLen = oldTokens.length;
11734	let editLength = 1;
11735	let maxEditLength = newLen + oldLen;
11736	if (options.maxEditLength != null) {
11737	maxEditLength = Math.min(maxEditLength, options.maxEditLength);
11738	}
11739	const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
11740	const abortAfterTimestamp = Date.now() + maxExecutionTime;
11741	const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
11742	let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
11743	if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
11744	return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
11745	}
11746	let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
11747	const execEditLength = () => {
11748	for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
11749	let basePath;
11750	const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
11751	if (removePath) {
11752	bestPath[diagonalPath - 1] = void 0;
11753	}
11754	let canAdd = false;
11755	if (addPath) {
11756	const addPathNewPos = addPath.oldPos - diagonalPath;
11757	canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
11758	}
11759	const canRemove = removePath && removePath.oldPos + 1 < oldLen;
11760	if (!canAdd && !canRemove) {
11761	bestPath[diagonalPath] = void 0;
11762	continue;
11763	}
11764	if (!canRemove \|\| canAdd && removePath.oldPos < addPath.oldPos) {
11765	basePath = this.addToPath(addPath, true, false, 0, options);
11766	} else {
11767	basePath = this.addToPath(removePath, false, true, 1, options);
11768	}
11769	newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
11770	if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
11771	return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) \|\| true;
11772	} else {
11773	bestPath[diagonalPath] = basePath;
11774	if (basePath.oldPos + 1 >= oldLen) {
11775	maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
11776	}
11777	if (newPos + 1 >= newLen) {
11778	minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
11779	}
11780	}
11781	}
11782	editLength++;
11783	};
11784	if (callback) {
11785	(function exec() {
11786	setTimeout(function() {
11787	if (editLength > maxEditLength \|\| Date.now() > abortAfterTimestamp) {
11788	return callback(void 0);
11789	}
11790	if (!execEditLength()) {
11791	exec();
11792	}
11793	}, 0);
11794	})();
11795	} else {
11796	while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
11797	const ret = execEditLength();
11798	if (ret) {
11799	return ret;
11800	}
11801	}
11802	}
11803	}
11804	addToPath(path, added, removed, oldPosInc, options) {
11805	const last2 = path.lastComponent;
11806	if (last2 && !options.oneChangePerToken && last2.added === added && last2.removed === removed) {
11807	return {
11808	oldPos: path.oldPos + oldPosInc,
11809	lastComponent: { count: last2.count + 1, added, removed, previousComponent: last2.previousComponent }
11810	};
11811	} else {
11812	return {
11813	oldPos: path.oldPos + oldPosInc,
11814	lastComponent: { count: 1, added, removed, previousComponent: last2 }
11815	};
11816	}
11817	}
11818	extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
11819	const newLen = newTokens.length, oldLen = oldTokens.length;
11820	let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
11821	while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
11822	newPos++;
11823	oldPos++;
11824	commonCount++;
11825	if (options.oneChangePerToken) {
11826	basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
11827	}
11828	}
11829	if (commonCount && !options.oneChangePerToken) {
11830	basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
11831	}
11832	basePath.oldPos = oldPos;
11833	return newPos;
11834	}
11835	equals(left, right, options) {
11836	if (options.comparator) {
11837	return options.comparator(left, right);
11838	} else {
11839	return left === right \|\| !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
11840	}
11841	}
11842	removeEmpty(array) {
11843	const ret = [];
11844	for (let i = 0; i < array.length; i++) {
11845	if (array[i]) {
11846	ret.push(array[i]);
11847	}
11848	}
11849	return ret;
11850	}
11851	// eslint-disable-next-line @typescript-eslint/no-unused-vars
11852	castInput(value, options) {
11853	return value;
11854	}
11855	// eslint-disable-next-line @typescript-eslint/no-unused-vars
11856	tokenize(value, options) {
11857	return Array.from(value);
11858	}
11859	join(chars) {
11860	return chars.join("");
11861	}
11862	postProcess(changeObjects, options) {
11863	return changeObjects;
11864	}
11865	get useLongestToken() {
11866	return false;
11867	}
11868	buildValues(lastComponent, newTokens, oldTokens) {
11869	const components = [];
11870	let nextComponent;
11871	while (lastComponent) {
11872	components.push(lastComponent);
11873	nextComponent = lastComponent.previousComponent;
11874	delete lastComponent.previousComponent;
11875	lastComponent = nextComponent;
11876	}
11877	components.reverse();
11878	const componentLen = components.length;
11879	let componentPos = 0, newPos = 0, oldPos = 0;
11880	for (; componentPos < componentLen; componentPos++) {
11881	const component = components[componentPos];
11882	if (!component.removed) {
11883	if (!component.added && this.useLongestToken) {
11884	let value = newTokens.slice(newPos, newPos + component.count);
11885	value = value.map(function(value2, i) {
11886	const oldValue = oldTokens[oldPos + i];
11887	return oldValue.length > value2.length ? oldValue : value2;
11888	});
11889	component.value = this.join(value);
11890	} else {
11891	component.value = this.join(newTokens.slice(newPos, newPos + component.count));
11892	}
11893	newPos += component.count;
11894	if (!component.added) {
11895	oldPos += component.count;
11896	}
11897	} else {
11898	component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
11899	oldPos += component.count;
11900	}
11901	}
11902	return components;
11903	}
11904	};
11905
11906	// node_modules/diff/libesm/diff/character.js
11907	var CharacterDiff = class extends Diff {
11908	};
11909	var characterDiff = new CharacterDiff();
11910	function diffChars(oldStr, newStr, options) {
11911	return characterDiff.diff(oldStr, newStr, options);
11912	}
11913
11914	// node_modules/diff/libesm/diff/line.js
11915	var LineDiff = class extends Diff {
11916	constructor() {
11917	super(...arguments);
11918	this.tokenize = tokenize;
11919	}
11920	equals(left, right, options) {
11921	if (options.ignoreWhitespace) {
11922	if (!options.newlineIsToken \|\| !left.includes("\n")) {
11923	left = left.trim();
11924	}
11925	if (!options.newlineIsToken \|\| !right.includes("\n")) {
11926	right = right.trim();
11927	}
11928	} else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
11929	if (left.endsWith("\n")) {
11930	left = left.slice(0, -1);
11931	}
11932	if (right.endsWith("\n")) {
11933	right = right.slice(0, -1);
11934	}
11935	}
11936	return super.equals(left, right, options);
11937	}
11938	};
11939	var lineDiff = new LineDiff();
11940	function diffLines(oldStr, newStr, options) {
11941	return lineDiff.diff(oldStr, newStr, options);
11942	}
11943	function tokenize(value, options) {
11944	if (options.stripTrailingCr) {
11945	value = value.replace(/\r\n/g, "\n");
11946	}
11947	const retLines = [], linesAndNewlines = value.split(/(\n\|\r\n)/);
11948	if (!linesAndNewlines[linesAndNewlines.length - 1]) {
11949	linesAndNewlines.pop();
11950	}
11951	for (let i = 0; i < linesAndNewlines.length; i++) {
11952	const line = linesAndNewlines[i];
11953	if (i % 2 && !options.newlineIsToken) {
11954	retLines[retLines.length - 1] += line;
11955	} else {
11956	retLines.push(line);
11957	}
11958	}
11959	return retLines;
11960	}
11961
11962	// packages/sync/build-module/quill-delta/Delta.mjs
11963	var import_es62 = __toESM(require_es6(), 1);
11964
11965	// packages/sync/build-module/quill-delta/AttributeMap.mjs
11966	var import_es6 = __toESM(require_es6(), 1);
11967	function cloneDeep(value) {
11968	return JSON.parse(JSON.stringify(value));
11969	}
11970	var AttributeMap;
11971	((AttributeMap2) => {
11972	function compose(a = {}, b = {}, keepNull = false) {
11973	if (typeof a !== "object") {
11974	a = {};
11975	}
11976	if (typeof b !== "object") {
11977	b = {};
11978	}
11979	let attributes = cloneDeep(b);
11980	if (!keepNull) {
11981	attributes = Object.keys(attributes).reduce(
11982	(copy2, key) => {
11983	if (attributes[key] !== null \|\| attributes[key] !== void 0) {
11984	copy2[key] = attributes[key];
11985	}
11986	return copy2;
11987	},
11988	{}
11989	);
11990	}
11991	for (const key in a) {
11992	if (a[key] !== void 0 && b[key] === void 0) {
11993	attributes[key] = a[key];
11994	}
11995	}
11996	return Object.keys(attributes).length > 0 ? attributes : void 0;
11997	}
11998	AttributeMap2.compose = compose;
11999	function diff(a = {}, b = {}) {
12000	if (typeof a !== "object") {
12001	a = {};
12002	}
12003	if (typeof b !== "object") {
12004	b = {};
12005	}
12006	const attributes = Object.keys(a).concat(Object.keys(b)).reduce((attrs, key) => {
12007	if (!(0, import_es6.default)(a[key], b[key])) {
12008	attrs[key] = b[key] === void 0 ? null : b[key];
12009	}
12010	return attrs;
12011	}, {});
12012	return Object.keys(attributes).length > 0 ? attributes : void 0;
12013	}
12014	AttributeMap2.diff = diff;
12015	function invert(attr = {}, base = {}) {
12016	attr = attr \|\| {};
12017	const baseInverted = Object.keys(base).reduce(
12018	(memo, key) => {
12019	if (base[key] !== attr[key] && attr[key] !== void 0) {
12020	memo[key] = base[key];
12021	}
12022	return memo;
12023	},
12024	{}
12025	);
12026	return Object.keys(attr).reduce((memo, key) => {
12027	if (attr[key] !== base[key] && base[key] === void 0) {
12028	memo[key] = null;
12029	}
12030	return memo;
12031	}, baseInverted);
12032	}
12033	AttributeMap2.invert = invert;
12034	function transform(a, b, priority = false) {
12035	if (typeof a !== "object") {
12036	return b;
12037	}
12038	if (typeof b !== "object") {
12039	return void 0;
12040	}
12041	if (!priority) {
12042	return b;
12043	}
12044	const attributes = Object.keys(b).reduce(
12045	(attrs, key) => {
12046	if (a[key] === void 0) {
12047	attrs[key] = b[key];
12048	}
12049	return attrs;
12050	},
12051	{}
12052	);
12053	return Object.keys(attributes).length > 0 ? attributes : void 0;
12054	}
12055	AttributeMap2.transform = transform;
12056	})(AttributeMap \|\| (AttributeMap = {}));
12057	var AttributeMap_default = AttributeMap;
12058
12059	// packages/sync/build-module/quill-delta/Op.mjs
12060	var Op;
12061	((Op2) => {
12062	function length2(op) {
12063	if (typeof op.delete === "number") {
12064	return op.delete;
12065	} else if (typeof op.retain === "number") {
12066	return op.retain;
12067	} else if (typeof op.retain === "object" && op.retain !== null) {
12068	return 1;
12069	}
12070	return typeof op.insert === "string" ? op.insert.length : 1;
12071	}
12072	Op2.length = length2;
12073	})(Op \|\| (Op = {}));
12074	var Op_default = Op;
12075
12076	// packages/sync/build-module/quill-delta/OpIterator.mjs
12077	var Iterator = class {
12078	ops;
12079	index;
12080	offset;
12081	constructor(ops) {
12082	this.ops = ops;
12083	this.index = 0;
12084	this.offset = 0;
12085	}
12086	hasNext() {
12087	return this.peekLength() < Infinity;
12088	}
12089	next(length2) {
12090	if (!length2) {
12091	length2 = Infinity;
12092	}
12093	const nextOp = this.ops[this.index];
12094	if (nextOp) {
12095	const offset = this.offset;
12096	const opLength = Op_default.length(nextOp);
12097	if (length2 >= opLength - offset) {
12098	length2 = opLength - offset;
12099	this.index += 1;
12100	this.offset = 0;
12101	} else {
12102	this.offset += length2;
12103	}
12104	if (typeof nextOp.delete === "number") {
12105	return { delete: length2 };
12106	}
12107	const retOp = {};
12108	if (nextOp.attributes) {
12109	retOp.attributes = nextOp.attributes;
12110	}
12111	if (typeof nextOp.retain === "number") {
12112	retOp.retain = length2;
12113	} else if (typeof nextOp.retain === "object" && nextOp.retain !== null) {
12114	retOp.retain = nextOp.retain;
12115	} else if (typeof nextOp.insert === "string") {
12116	retOp.insert = nextOp.insert.substr(offset, length2);
12117	} else {
12118	retOp.insert = nextOp.insert;
12119	}
12120	return retOp;
12121	}
12122	return { retain: Infinity };
12123	}
12124	peek() {
12125	return this.ops[this.index];
12126	}
12127	peekLength() {
12128	if (this.ops[this.index]) {
12129	return Op_default.length(this.ops[this.index]) - this.offset;
12130	}
12131	return Infinity;
12132	}
12133	peekType() {
12134	const op = this.ops[this.index];
12135	if (op) {
12136	if (typeof op.delete === "number") {
12137	return "delete";
12138	} else if (typeof op.retain === "number" \|\| typeof op.retain === "object" && op.retain !== null) {
12139	return "retain";
12140	}
12141	return "insert";
12142	}
12143	return "retain";
12144	}
12145	rest() {
12146	if (!this.hasNext()) {
12147	return [];
12148	} else if (this.offset === 0) {
12149	return this.ops.slice(this.index);
12150	}
12151	const offset = this.offset;
12152	const index = this.index;
12153	const next = this.next();
12154	const rest = this.ops.slice(this.index);
12155	this.offset = offset;
12156	this.index = index;
12157	return [next].concat(rest);
12158	}
12159	};
12160
12161	// packages/sync/build-module/quill-delta/Delta.mjs
12162	function cloneDeep2(value) {
12163	return JSON.parse(JSON.stringify(value));
12164	}
12165	var NULL_CHARACTER = String.fromCharCode(0);
12166	var STRING_TOO_LARGE_THRESHOLD = 1e4;
12167	function normalizeChangeCounts(changes) {
12168	return changes.map((change) => ({
12169	...change,
12170	count: change.value.length
12171	}));
12172	}
12173	var getEmbedTypeAndData = (a, b) => {
12174	if (typeof a !== "object" \|\| a === null) {
12175	throw new Error(`cannot retain a ${typeof a}`);
12176	}
12177	if (typeof b !== "object" \|\| b === null) {
12178	throw new Error(`cannot retain a ${typeof b}`);
12179	}
12180	const embedType = Object.keys(a)[0];
12181	if (!embedType \|\| embedType !== Object.keys(b)[0]) {
12182	throw new Error(
12183	`embed types not matched: ${embedType} != ${Object.keys(b)[0]}`
12184	);
12185	}
12186	return [embedType, a[embedType], b[embedType]];
12187	};
12188	var Delta = class _Delta {
12189	static Op = Op_default;
12190	static OpIterator = Iterator;
12191	static AttributeMap = AttributeMap_default;
12192	static handlers = {};
12193	static registerEmbed(embedType, handler) {
12194	this.handlers[embedType] = handler;
12195	}
12196	static unregisterEmbed(embedType) {
12197	delete this.handlers[embedType];
12198	}
12199	static getHandler(embedType) {
12200	const handler = this.handlers[embedType];
12201	if (!handler) {
12202	throw new Error(`no handlers for embed type "${embedType}"`);
12203	}
12204	return handler;
12205	}
12206	ops;
12207	constructor(ops) {
12208	if (Array.isArray(ops)) {
12209	this.ops = ops;
12210	} else if (ops !== null && ops !== void 0 && Array.isArray(ops.ops)) {
12211	this.ops = ops.ops;
12212	} else {
12213	this.ops = [];
12214	}
12215	}
12216	insert(arg, attributes) {
12217	const newOp = {};
12218	if (typeof arg === "string" && arg.length === 0) {
12219	return this;
12220	}
12221	newOp.insert = arg;
12222	if (attributes !== null && attributes !== void 0 && typeof attributes === "object" && Object.keys(attributes).length > 0) {
12223	newOp.attributes = attributes;
12224	}
12225	return this.push(newOp);
12226	}
12227	delete(length2) {
12228	if (length2 <= 0) {
12229	return this;
12230	}
12231	return this.push({ delete: length2 });
12232	}
12233	retain(length2, attributes) {
12234	if (typeof length2 === "number" && length2 <= 0) {
12235	return this;
12236	}
12237	const newOp = { retain: length2 };
12238	if (attributes !== null && attributes !== void 0 && typeof attributes === "object" && Object.keys(attributes).length > 0) {
12239	newOp.attributes = attributes;
12240	}
12241	return this.push(newOp);
12242	}
12243	push(newOp) {
12244	let index = this.ops.length;
12245	let lastOp = this.ops[index - 1];
12246	newOp = cloneDeep2(newOp);
12247	if (typeof lastOp === "object") {
12248	if (typeof newOp.delete === "number" && typeof lastOp.delete === "number") {
12249	this.ops[index - 1] = {
12250	delete: lastOp.delete + newOp.delete
12251	};
12252	return this;
12253	}
12254	if (typeof lastOp.delete === "number" && newOp.insert !== null && newOp.insert !== void 0) {
12255	index -= 1;
12256	lastOp = this.ops[index - 1];
12257	if (typeof lastOp !== "object") {
12258	this.ops.unshift(newOp);
12259	return this;
12260	}
12261	}
12262	if ((0, import_es62.default)(newOp.attributes, lastOp.attributes)) {
12263	if (typeof newOp.insert === "string" && typeof lastOp.insert === "string") {
12264	this.ops[index - 1] = {
12265	insert: lastOp.insert + newOp.insert
12266	};
12267	if (typeof newOp.attributes === "object") {
12268	this.ops[index - 1].attributes = newOp.attributes;
12269	}
12270	return this;
12271	} else if (typeof newOp.retain === "number" && typeof lastOp.retain === "number") {
12272	this.ops[index - 1] = {
12273	retain: lastOp.retain + newOp.retain
12274	};
12275	if (typeof newOp.attributes === "object") {
12276	this.ops[index - 1].attributes = newOp.attributes;
12277	}
12278	return this;
12279	}
12280	}
12281	}
12282	if (index === this.ops.length) {
12283	this.ops.push(newOp);
12284	} else {
12285	this.ops.splice(index, 0, newOp);
12286	}
12287	return this;
12288	}
12289	chop() {
12290	const lastOp = this.ops[this.ops.length - 1];
12291	if (lastOp && typeof lastOp.retain === "number" && !lastOp.attributes) {
12292	this.ops.pop();
12293	}
12294	return this;
12295	}
12296	filter(predicate) {
12297	return this.ops.filter(predicate);
12298	}
12299	forEach(predicate) {
12300	this.ops.forEach(predicate);
12301	}
12302	map(predicate) {
12303	return this.ops.map(predicate);
12304	}
12305	partition(predicate) {
12306	const passed = [];
12307	const failed = [];
12308	this.forEach((op) => {
12309	const target = predicate(op) ? passed : failed;
12310	target.push(op);
12311	});
12312	return [passed, failed];
12313	}
12314	reduce(predicate, initialValue) {
12315	return this.ops.reduce(predicate, initialValue);
12316	}
12317	changeLength() {
12318	return this.reduce((length2, elem) => {
12319	if (elem.insert) {
12320	return length2 + Op_default.length(elem);
12321	} else if (elem.delete) {
12322	return length2 - elem.delete;
12323	}
12324	return length2;
12325	}, 0);
12326	}
12327	length() {
12328	return this.reduce((length2, elem) => {
12329	return length2 + Op_default.length(elem);
12330	}, 0);
12331	}
12332	slice(start = 0, end = Infinity) {
12333	const ops = [];
12334	const iter = new Iterator(this.ops);
12335	let index = 0;
12336	while (index < end && iter.hasNext()) {
12337	let nextOp;
12338	if (index < start) {
12339	nextOp = iter.next(start - index);
12340	} else {
12341	nextOp = iter.next(end - index);
12342	ops.push(nextOp);
12343	}
12344	index += Op_default.length(nextOp);
12345	}
12346	return new _Delta(ops);
12347	}
12348	compose(other) {
12349	const thisIter = new Iterator(this.ops);
12350	const otherIter = new Iterator(other.ops);
12351	const ops = [];
12352	const firstOther = otherIter.peek();
12353	if (firstOther !== null && firstOther !== void 0 && typeof firstOther.retain === "number" && (firstOther.attributes === null \|\| firstOther.attributes === void 0)) {
12354	let firstLeft = firstOther.retain;
12355	while (thisIter.peekType() === "insert" && thisIter.peekLength() <= firstLeft) {
12356	firstLeft -= thisIter.peekLength();
12357	ops.push(thisIter.next());
12358	}
12359	if (firstOther.retain - firstLeft > 0) {
12360	otherIter.next(firstOther.retain - firstLeft);
12361	}
12362	}
12363	const delta = new _Delta(ops);
12364	while (thisIter.hasNext() \|\| otherIter.hasNext()) {
12365	if (otherIter.peekType() === "insert") {
12366	delta.push(otherIter.next());
12367	} else if (thisIter.peekType() === "delete") {
12368	delta.push(thisIter.next());
12369	} else {
12370	const length2 = Math.min(
12371	thisIter.peekLength(),
12372	otherIter.peekLength()
12373	);
12374	const thisOp = thisIter.next(length2);
12375	const otherOp = otherIter.next(length2);
12376	if (otherOp.retain) {
12377	const newOp = {};
12378	if (typeof thisOp.retain === "number") {
12379	newOp.retain = typeof otherOp.retain === "number" ? length2 : otherOp.retain;
12380	} else if (typeof otherOp.retain === "number") {
12381	if (thisOp.retain === null \|\| thisOp.retain === void 0) {
12382	newOp.insert = thisOp.insert;
12383	} else {
12384	newOp.retain = thisOp.retain;
12385	}
12386	} else {
12387	const action = thisOp.retain === null \|\| thisOp.retain === void 0 ? "insert" : "retain";
12388	const [embedType, thisData, otherData] = getEmbedTypeAndData(
12389	thisOp[action],
12390	otherOp.retain
12391	);
12392	const handler = _Delta.getHandler(embedType);
12393	newOp[action] = {
12394	[embedType]: handler.compose(
12395	thisData,
12396	otherData,
12397	action === "retain"
12398	)
12399	};
12400	}
12401	const attributes = AttributeMap_default.compose(
12402	thisOp.attributes,
12403	otherOp.attributes,
12404	typeof thisOp.retain === "number"
12405	);
12406	if (attributes) {
12407	newOp.attributes = attributes;
12408	}
12409	delta.push(newOp);
12410	if (!otherIter.hasNext() && (0, import_es62.default)(delta.ops[delta.ops.length - 1], newOp)) {
12411	const rest = new _Delta(thisIter.rest());
12412	return delta.concat(rest).chop();
12413	}
12414	} else if (typeof otherOp.delete === "number" && (typeof thisOp.retain === "number" \|\| typeof thisOp.retain === "object" && thisOp.retain !== null)) {
12415	delta.push(otherOp);
12416	}
12417	}
12418	}
12419	return delta.chop();
12420	}
12421	concat(other) {
12422	const delta = new _Delta(this.ops.slice());
12423	if (other.ops.length > 0) {
12424	delta.push(other.ops[0]);
12425	delta.ops = delta.ops.concat(other.ops.slice(1));
12426	}
12427	return delta;
12428	}
12429	diff(other) {
12430	if (this.ops === other.ops) {
12431	return new _Delta();
12432	}
12433	const strings = this.deltasToStrings(other);
12434	const diffResult = normalizeChangeCounts(
12435	diffChars(strings[0], strings[1])
12436	);
12437	const thisIter = new Iterator(this.ops);
12438	const otherIter = new Iterator(other.ops);
12439	const retDelta = this.convertChangesToDelta(
12440	diffResult,
12441	thisIter,
12442	otherIter
12443	);
12444	return retDelta.chop();
12445	}
12446	eachLine(predicate, newline = "\n") {
12447	const iter = new Iterator(this.ops);
12448	let line = new _Delta();
12449	let i = 0;
12450	while (iter.hasNext()) {
12451	if (iter.peekType() !== "insert") {
12452	return;
12453	}
12454	const thisOp = iter.peek();
12455	const start = Op_default.length(thisOp) - iter.peekLength();
12456	const index = typeof thisOp.insert === "string" ? thisOp.insert.indexOf(newline, start) - start : -1;
12457	if (index < 0) {
12458	line.push(iter.next());
12459	} else if (index > 0) {
12460	line.push(iter.next(index));
12461	} else {
12462	if (predicate(line, iter.next(1).attributes \|\| {}, i) === false) {
12463	return;
12464	}
12465	i += 1;
12466	line = new _Delta();
12467	}
12468	}
12469	if (line.length() > 0) {
12470	predicate(line, {}, i);
12471	}
12472	}
12473	invert(base) {
12474	const inverted = new _Delta();
12475	this.reduce((baseIndex, op) => {
12476	if (op.insert) {
12477	inverted.delete(Op_default.length(op));
12478	} else if (typeof op.retain === "number" && (op.attributes === null \|\| op.attributes === void 0)) {
12479	inverted.retain(op.retain);
12480	return baseIndex + op.retain;
12481	} else if (op.delete \|\| typeof op.retain === "number") {
12482	const length2 = op.delete \|\| op.retain;
12483	const slice = base.slice(baseIndex, baseIndex + length2);
12484	slice.forEach((baseOp) => {
12485	if (op.delete) {
12486	inverted.push(baseOp);
12487	} else if (op.retain && op.attributes) {
12488	inverted.retain(
12489	Op_default.length(baseOp),
12490	AttributeMap_default.invert(
12491	op.attributes,
12492	baseOp.attributes
12493	)
12494	);
12495	}
12496	});
12497	return baseIndex + length2;
12498	} else if (typeof op.retain === "object" && op.retain !== null) {
12499	const slice = base.slice(baseIndex, baseIndex + 1);
12500	const baseOp = new Iterator(slice.ops).next();
12501	const [embedType, opData, baseOpData] = getEmbedTypeAndData(
12502	op.retain,
12503	baseOp.insert
12504	);
12505	const handler = _Delta.getHandler(embedType);
12506	inverted.retain(
12507	{ [embedType]: handler.invert(opData, baseOpData) },
12508	AttributeMap_default.invert(op.attributes, baseOp.attributes)
12509	);
12510	return baseIndex + 1;
12511	}
12512	return baseIndex;
12513	}, 0);
12514	return inverted.chop();
12515	}
12516	transform(arg, priority = false) {
12517	priority = !!priority;
12518	if (typeof arg === "number") {
12519	return this.transformPosition(arg, priority);
12520	}
12521	const other = arg;
12522	const thisIter = new Iterator(this.ops);
12523	const otherIter = new Iterator(other.ops);
12524	const delta = new _Delta();
12525	while (thisIter.hasNext() \|\| otherIter.hasNext()) {
12526	if (thisIter.peekType() === "insert" && (priority \|\| otherIter.peekType() !== "insert")) {
12527	delta.retain(Op_default.length(thisIter.next()));
12528	} else if (otherIter.peekType() === "insert") {
12529	delta.push(otherIter.next());
12530	} else {
12531	const length2 = Math.min(
12532	thisIter.peekLength(),
12533	otherIter.peekLength()
12534	);
12535	const thisOp = thisIter.next(length2);
12536	const otherOp = otherIter.next(length2);
12537	if (thisOp.delete) {
12538	continue;
12539	} else if (otherOp.delete) {
12540	delta.push(otherOp);
12541	} else {
12542	const thisData = thisOp.retain;
12543	const otherData = otherOp.retain;
12544	let transformedData = typeof otherData === "object" && otherData !== null ? otherData : length2;
12545	if (typeof thisData === "object" && thisData !== null && typeof otherData === "object" && otherData !== null) {
12546	const embedType = Object.keys(thisData)[0];
12547	if (embedType === Object.keys(otherData)[0]) {
12548	const handler = _Delta.getHandler(embedType);
12549	if (handler) {
12550	transformedData = {
12551	[embedType]: handler.transform(
12552	thisData[embedType],
12553	otherData[embedType],
12554	priority
12555	)
12556	};
12557	}
12558	}
12559	}
12560	delta.retain(
12561	transformedData,
12562	AttributeMap_default.transform(
12563	thisOp.attributes,
12564	otherOp.attributes,
12565	priority
12566	)
12567	);
12568	}
12569	}
12570	}
12571	return delta.chop();
12572	}
12573	transformPosition(index, priority = false) {
12574	priority = !!priority;
12575	const thisIter = new Iterator(this.ops);
12576	let offset = 0;
12577	while (thisIter.hasNext() && offset <= index) {
12578	const length2 = thisIter.peekLength();
12579	const nextType = thisIter.peekType();
12580	thisIter.next();
12581	if (nextType === "delete") {
12582	index -= Math.min(length2, index - offset);
12583	continue;
12584	} else if (nextType === "insert" && (offset < index \|\| !priority)) {
12585	index += length2;
12586	}
12587	offset += length2;
12588	}
12589	return index;
12590	}
12591	/**
12592	* Given a Delta and a cursor position, do a diff and attempt to adjust
12593	* the diff to place insertions or deletions at the cursor position.
12594	*
12595	* @todo There are at least a few known cases where this produces a corrupted
12596	* diff. When this is fixed, it should not be necessary to verify that the
12597	* transformed diff applies cleanly.
12598	*
12599	* @see import("@wordpress/core-data/src/utils/crdt-blocks").mergeRichTextUpdate()
12600	*
12601	* @param other - The other Delta to diff against.
12602	* @param cursorAfterChange - The cursor position index after the change.
12603	* @return A Delta that attempts to place insertions or deletions at the cursor position.
12604	*/
12605	diffWithCursor(other, cursorAfterChange) {
12606	if (this.ops === other.ops) {
12607	return new _Delta();
12608	}
12609	const strings = this.deltasToStrings(other);
12610	const maxStringLength = Math.max(
12611	...strings.map((str) => str.length)
12612	);
12613	if (maxStringLength > STRING_TOO_LARGE_THRESHOLD) {
12614	const diffResult = normalizeChangeCounts(
12615	diffLines(strings[0], strings[1])
12616	);
12617	const thisIterLarge = new Iterator(this.ops);
12618	const otherIterLarge = new Iterator(other.ops);
12619	return this.convertChangesToDelta(
12620	diffResult,
12621	thisIterLarge,
12622	otherIterLarge
12623	).chop();
12624	} else if (cursorAfterChange === null) {
12625	return this.diff(other);
12626	}
12627	let diffs = normalizeChangeCounts(
12628	diffChars(strings[0], strings[1])
12629	);
12630	let lastDiffPosition = 0;
12631	const adjustedDiffs = [];
12632	for (let i = 0; i < diffs.length; i++) {
12633	const diff = diffs[i];
12634	const segmentStart = lastDiffPosition;
12635	const segmentEnd = lastDiffPosition + (diff.count ?? 0);
12636	const isCursorInSegment = cursorAfterChange > segmentStart && cursorAfterChange <= segmentEnd;
12637	const isUnchangedSegment = !diff.added && !diff.removed;
12638	const isRemovalSegment = diff.removed && !diff.added;
12639	const nextDiff = diffs[i + 1];
12640	const isNextDiffAnInsert = nextDiff && nextDiff.added && !nextDiff.removed;
12641	if (isUnchangedSegment && isCursorInSegment && isNextDiffAnInsert) {
12642	const movedSegments = this.tryMoveInsertionToCursor(
12643	diff,
12644	nextDiff,
12645	cursorAfterChange,
12646	segmentStart
12647	);
12648	if (movedSegments) {
12649	adjustedDiffs.push(...movedSegments);
12650	i++;
12651	lastDiffPosition = segmentEnd;
12652	continue;
12653	}
12654	}
12655	if (isRemovalSegment) {
12656	const movedSegments = this.tryMoveDeletionToCursor(
12657	diff,
12658	adjustedDiffs,
12659	cursorAfterChange,
12660	lastDiffPosition
12661	);
12662	if (movedSegments) {
12663	adjustedDiffs.pop();
12664	adjustedDiffs.push(...movedSegments);
12665	lastDiffPosition += diff.count ?? 0;
12666	continue;
12667	}
12668	}
12669	adjustedDiffs.push(diff);
12670	if (!diff.added) {
12671	lastDiffPosition += diff.count ?? 0;
12672	}
12673	}
12674	diffs = adjustedDiffs;
12675	const thisIter = new Iterator(this.ops);
12676	const otherIter = new Iterator(other.ops);
12677	const retDelta = this.convertChangesToDelta(
12678	diffs,
12679	thisIter,
12680	otherIter
12681	);
12682	return retDelta.chop();
12683	}
12684	/**
12685	* Try to move an insertion operation from after an unchanged segment to the cursor position within it.
12686	* This is a "look-ahead" strategy.
12687	*
12688	* @param diff - The current unchanged diff segment.
12689	* @param nextDiff - The next diff segment (expected to be an insertion).
12690	* @param cursorAfterChange - The cursor position after the change.
12691	* @param segmentStart - The start position of the current segment.
12692	* @return An array of adjusted diff segments if the insertion was successfully moved, null otherwise.
12693	*/
12694	tryMoveInsertionToCursor(diff, nextDiff, cursorAfterChange, segmentStart) {
12695	const nextDiffInsert = nextDiff.value;
12696	const insertLength = nextDiffInsert.length;
12697	const insertOffset = cursorAfterChange - segmentStart - insertLength;
12698	const textAtCursor = diff.value.substring(
12699	insertOffset,
12700	insertOffset + nextDiffInsert.length
12701	);
12702	const isInsertMoveable = textAtCursor === nextDiffInsert;
12703	if (!isInsertMoveable) {
12704	return null;
12705	}
12706	const beforeCursor = diff.value.substring(0, insertOffset);
12707	const afterCursor = diff.value.substring(insertOffset);
12708	const result = [];
12709	if (beforeCursor.length > 0) {
12710	result.push({
12711	value: beforeCursor,
12712	count: beforeCursor.length,
12713	added: false,
12714	removed: false
12715	});
12716	}
12717	result.push(nextDiff);
12718	if (afterCursor.length > 0) {
12719	result.push({
12720	value: afterCursor,
12721	count: afterCursor.length,
12722	added: false,
12723	removed: false
12724	});
12725	}
12726	return result;
12727	}
12728	/**
12729	* Try to move a deletion operation to the cursor position by looking back at the previous unchanged segment.
12730	* This is a "look-back" strategy.
12731	*
12732	* @param diff - The current deletion diff segment.
12733	* @param adjustedDiffs - The array of previously processed diff segments.
12734	* @param cursorAfterChange - The cursor position after the change.
12735	* @param lastDiffPosition - The position in the document up to (but not including) the current diff.
12736	* @return An array of adjusted diff segments if the deletion was successfully moved, null otherwise.
12737	*/
12738	tryMoveDeletionToCursor(diff, adjustedDiffs, cursorAfterChange, lastDiffPosition) {
12739	const prevDiff = adjustedDiffs[adjustedDiffs.length - 1];
12740	if (!prevDiff \|\| prevDiff.added \|\| prevDiff.removed) {
12741	return null;
12742	}
12743	const prevSegmentStart = lastDiffPosition - (prevDiff.count ?? 0);
12744	const prevSegmentEnd = lastDiffPosition;
12745	if (cursorAfterChange < prevSegmentStart \|\| cursorAfterChange >= prevSegmentEnd) {
12746	return null;
12747	}
12748	const deletedChars = diff.value;
12749	const deleteOffset = cursorAfterChange - prevSegmentStart;
12750	const textAtCursor = prevDiff.value.substring(
12751	deleteOffset,
12752	deleteOffset + deletedChars.length
12753	);
12754	const canBePlacedHere = textAtCursor === deletedChars;
12755	if (!canBePlacedHere) {
12756	return null;
12757	}
12758	const beforeCursor = prevDiff.value.substring(0, deleteOffset);
12759	const atAndAfterCursor = prevDiff.value.substring(deleteOffset);
12760	const deletionLength = diff.count ?? 0;
12761	const afterDeletion = atAndAfterCursor.substring(deletionLength);
12762	const result = [];
12763	if (beforeCursor.length > 0) {
12764	result.push({
12765	value: beforeCursor,
12766	count: beforeCursor.length,
12767	added: false,
12768	removed: false
12769	});
12770	}
12771	result.push(diff);
12772	if (afterDeletion.length > 0) {
12773	result.push({
12774	value: afterDeletion,
12775	count: afterDeletion.length,
12776	added: false,
12777	removed: false
12778	});
12779	}
12780	return result;
12781	}
12782	/**
12783	* Convert two Deltas to string representations for diffing.
12784	*
12785	* @param other - The other Delta to convert.
12786	* @return A tuple of [thisString, otherString].
12787	*/
12788	deltasToStrings(other) {
12789	return [this, other].map((delta) => {
12790	return delta.map((op) => {
12791	if (op.insert !== null \|\| op.insert !== void 0) {
12792	return typeof op.insert === "string" ? op.insert : NULL_CHARACTER;
12793	}
12794	const prep = delta === other ? "on" : "with";
12795	throw new Error(
12796	"diff() called " + prep + " non-document"
12797	);
12798	}).join("");
12799	});
12800	}
12801	/**
12802	* Process diff changes and convert them to Delta operations.
12803	*
12804	* @param changes - The array of changes from the diff algorithm.
12805	* @param thisIter - Iterator for this Delta's operations.
12806	* @param otherIter - Iterator for the other Delta's operations.
12807	* @return A Delta containing the processed diff operations.
12808	*/
12809	convertChangesToDelta(changes, thisIter, otherIter) {
12810	const retDelta = new _Delta();
12811	changes.forEach((component) => {
12812	let length2 = component.count ?? 0;
12813	while (length2 > 0) {
12814	let opLength = 0;
12815	if (component.added) {
12816	opLength = Math.min(otherIter.peekLength(), length2);
12817	retDelta.push(otherIter.next(opLength));
12818	} else if (component.removed) {
12819	opLength = Math.min(length2, thisIter.peekLength());
12820	thisIter.next(opLength);
12821	retDelta.delete(opLength);
12822	} else {
12823	opLength = Math.min(
12824	thisIter.peekLength(),
12825	otherIter.peekLength(),
12826	length2
12827	);
12828	const thisOp = thisIter.next(opLength);
12829	const otherOp = otherIter.next(opLength);
12830	if ((0, import_es62.default)(thisOp.insert, otherOp.insert)) {
12831	retDelta.retain(
12832	opLength,
12833	AttributeMap_default.diff(
12834	thisOp.attributes,
12835	otherOp.attributes
12836	)
12837	);
12838	} else {
12839	retDelta.push(otherOp).delete(opLength);
12840	}
12841	}
12842	length2 -= opLength;
12843	}
12844	});
12845	return retDelta;
12846	}
12847	};
12848	var Delta_default = Delta;
12849
12850	// packages/sync/build-module/private-apis.mjs
12851	var privateApis = {};
12852	lock(privateApis, {
12853	ConnectionErrorCode,
12854	createSyncManager,
12855	Delta: Delta_default,
12856	CRDT_DOC_META_PERSISTENCE_KEY,
12857	CRDT_RECORD_MAP_KEY,
12858	LOCAL_EDITOR_ORIGIN,
12859	LOCAL_UNDO_IGNORED_ORIGIN,
12860	retrySyncConnection: () => pollingManager.retryNow()
12861	});
12862
12863	// packages/sync/build-module/index.mjs
12864	var YJS_VERSION = "13";
12865	return __toCommonJS(index_exports);
12866	})();
12867	//# sourceMappingURL=index.js.map
12868