@pcg/dynamic-components 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1564 @@
+import * as Y from "yjs";
+import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
+
+//#region src/assertions/basic.ts
+/**
+* Checks if the given parameter is callable (a function).
+* @param {unknown} fn - The function to check.
+* @returns {boolean} Returns true if `fn` is a function, false otherwise.
+* @example
+* isCallable(() => {});  // Returns true
+* isCallable('Hello');  // Returns false
+*/
+const isCallable = (fn) => {
+	return typeof fn === "function";
+};
+/**
+* Checks if the given value is a string.
+* @param {unknown} val - The value to check.
+* @returns {boolean} Returns true if `val` is a string, false otherwise.
+* @example
+* isString('Hello');  // Returns true
+* isString(123);  // Returns false
+*/
+const isString = (val) => typeof val === "string";
+/**
+* Checks if the given value is a number.
+* @param {unknown} val - The value to check.
+* @returns {boolean} Returns true if `val` is a number, false otherwise.
+* @example
+* isNumber(123);  // Returns true
+* isNumber('Hello');  // Returns false
+*/
+const isNumber = (val) => typeof val === "number";
+/**
+* Checks if a given value can be used as an index (a non-negative integer).
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` can be used as an index, false otherwise.
+* @example
+* isIndex(2);  // Returns true
+* isIndex('2');  // Returns true
+* isIndex(-1);  // Returns false
+*/
+const isIndex = (value) => {
+	return (isNumber(value) || isString(value)) && Number(value) >= 0;
+};
+/**
+* Checks if the given value is null or undefined.
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is null or undefined, false otherwise.
+* @example
+* isNullOrUndefined(null);  // Returns true
+* isNullOrUndefined(undefined);  // Returns true
+* isNullOrUndefined('Hello');  // Returns false
+*/
+const isNullOrUndefined = (value) => {
+	return value === null || value === void 0;
+};
+
+//#endregion
+//#region src/assertions/containers.ts
+/**
+* Checks if the given value is an empty array.
+* @param {unknown} arr - The array to check.
+* @returns {boolean} Returns true if `arr` is an empty array, false otherwise.
+* @example
+* isEmptyArray([]);  // Returns true
+* isEmptyArray([1, 2, 3]);  // Returns false
+*/
+const isEmptyArray = (arr) => {
+	return Array.isArray(arr) && arr.length === 0;
+};
+/**
+* Gets the keys of the given object.
+* @param {T} arr - The object to get the keys from.
+* @returns {Array<keyof T>} Returns an array of keys of the given object.
+* @example
+* keysOf({ a: 1, b: 2 });  // Returns ['a', 'b']
+*/
+const keysOf = (arr) => Object.keys(arr);
+/**
+* Gets the entries of the given object.
+* @param {T} arr - The object to get the entries from.
+* @returns {Entries<T>} Returns an array of entries of the given object.
+* @example
+* entriesOf({ a: 1, b: 2 });  // Returns [['a', 1], ['b', 2]]
+*/
+const entriesOf = (arr) => Object.entries(arr);
+/**
+* Checks if the given value is an object (not an array).
+* @param {unknown} obj - The value to check.
+* @returns {boolean} Returns true if `obj` is an object, false otherwise.
+* @example
+* isObject({ a: 1 });  // Returns true
+* isObject([1, 2, 3]);  // Returns false
+*/
+const isObject = (obj) => obj !== null && !!obj && typeof obj === "object" && !Array.isArray(obj);
+/**
+* Checks if the given value is a container (an object or an array).
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is a container, false otherwise.
+* @example
+* isContainerValue({ a: 1 });  // Returns true
+* isContainerValue([1, 2, 3]);  // Returns true
+* isContainerValue('Hello');  // Returns false
+*/
+const isContainerValue = (value) => {
+	return isObject(value) || Array.isArray(value);
+};
+/**
+* Checks if the given value is an empty container (an empty object or array).
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is an empty container, false otherwise.
+* @example
+* isEmptyContainer({});  // Returns true
+* isEmptyContainer([]);  // Returns true
+* isEmptyContainer({ a: 1 });  // Returns false
+* isEmptyContainer([1, 2, 3]);  // Returns false
+*/
+const isEmptyContainer = (value) => {
+	if (Array.isArray(value)) return value.length === 0;
+	return isObject(value) && Object.keys(value).length === 0;
+};
+
+//#endregion
+//#region src/assertions/paths.ts
+/**
+* Checks if two paths are equal.
+* @param {(string | number)[]} path - The first path to compare.
+* @param {(string | number)[]} toPath - The second path to compare.
+* @returns {boolean} Returns true if both paths are of the same length and all corresponding elements are equal, false otherwise.
+* @example
+* isEqualPath(['items', 'id:xxx', 'name'], ['items', 'id:xxx', 'name']);  // Returns true
+* isEqualPath(['items', 'id:yyy', 'name'], ['items', 'id:xxx', 'name']);  // Returns false
+*/
+const isEqualPath = (path, toPath) => {
+	return path.length === toPath.length && path.every((v, index) => v === toPath[index]);
+};
+
+//#endregion
+//#region src/assertions/rich-text.ts
+/**
+* Checks if the given value is a RichText object.
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is a RichText object, false otherwise.
+* @example
+* isRichText({ id: 'xx', ... type: 'RichText' });  // Returns true
+*/
+const isRichText = (value) => {
+	if (typeof value === "object" && value !== null) return "type" in value && value.type === "RichText";
+	return false;
+};
+
+//#endregion
+//#region src/assertions/yjs.ts
+/**
+* Checks if the given value is a Yjs Map.
+* @param {unknown} yMap - The value to check.
+* @returns {boolean} Returns true if `yMap` is a Yjs Map, false otherwise.
+* @example
+* const yMap = new Y.Map();
+* isYMap(yMap);  // Returns true
+*/
+const isYMap = (yMap) => {
+	return yMap instanceof Y.Map;
+};
+/**
+* Checks if the given value is a Yjs Array.
+* @param {unknown} yArray - The value to check.
+* @returns {boolean} Returns true if `yArray` is a Yjs Array, false otherwise.
+* @example
+* const yArray = new Y.Array();
+* isYArray(yArray);  // Returns true
+*/
+const isYArray = (yArray) => {
+	return yArray instanceof Y.Array;
+};
+
+//#endregion
+//#region src/data-objects/data-object.ts
+/**
+* Gets the key of the data object. The key is a string combining `type` and `id` of the data object, separated by a colon.
+* @param {BaseDataObject} dataObject - The data object to get the key from.
+* @returns {string} Returns the key of the data object.
+* @example
+* getDataObjectKey({ id: 'xxx', type: 'RichText' });  // Returns 'RichText:xxx'
+*/
+const getDataObjectKey = (dataObject) => {
+	return `${dataObject.type}:${dataObject.id}`;
+};
+
+//#endregion
+//#region src/dynamic-components/fractional-indexing.ts
+const BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const SMALLEST_INTEGER = "A00000000000000000000000000";
+const INTEGER_ZERO = "a0";
+/**
+* @param {string} a
+* @param {string | null} b
+* @param {string} digits
+* @returns {string}
+*/
+const midpoint = (a, b, digits) => {
+	if (b !== null && a >= b) throw new Error(a + " >= " + b);
+	if (a.slice(-1) === "0" || b && b.slice(-1) === "0") throw new Error("trailing zero");
+	if (b) {
+		let n = 0;
+		while ((a[n] || "0") === b[n]) n++;
+		if (n > 0) return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+	}
+	const digitA = a ? digits.indexOf(a[0]) : 0;
+	const digitB = b !== null ? digits.indexOf(b[0]) : digits.length;
+	if (digitB - digitA > 1) return digits[Math.round(.5 * (digitA + digitB))];
+	else {
+		if (b && b.length > 1) return b.slice(0, 1);
+		return digits[digitA] + midpoint(a.slice(1), null, digits);
+	}
+};
+/**
+* @param {string} int
+* @return {void}
+*/
+const validateInteger = (int) => {
+	if (int.length !== getIntegerLength(int[0])) throw new Error("invalid integer part of order key: " + int);
+};
+/**
+* @param {string} head
+* @return {number}
+*/
+const getIntegerLength = (head) => {
+	if (head >= "a" && head <= "z") return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
+	else if (head >= "A" && head <= "Z") return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
+	else throw new Error("invalid order key head: " + head);
+};
+/**
+* @param {string} key
+* @return {string}
+*/
+const getIntegerPart = (key) => {
+	const integerPartLength = getIntegerLength(key[0]);
+	if (integerPartLength > key.length) throw new Error("invalid order key: " + key);
+	return key.slice(0, integerPartLength);
+};
+/**
+* @param {string} key
+* @return {void}
+*/
+const validateOrderKey = (key) => {
+	if (key === SMALLEST_INTEGER) throw new Error("invalid order key: " + key);
+	const i = getIntegerPart(key);
+	if (key.slice(i.length).slice(-1) === "0") throw new Error("invalid order key: " + key);
+};
+/**
+* @param {string} x
+* @param {string} digits
+* @return {string | null}
+*/
+const incrementInteger = (x, digits) => {
+	validateInteger(x);
+	const [head, ...digs] = x.split("");
+	let carry = true;
+	for (let i = digs.length - 1; carry && i >= 0; i--) {
+		const d = digits.indexOf(digs[i]) + 1;
+		if (d === digits.length) digs[i] = "0";
+		else {
+			digs[i] = digits[d];
+			carry = false;
+		}
+	}
+	if (carry) {
+		if (head === "Z") return "a0";
+		if (head === "z") return null;
+		const h = String.fromCharCode(head.charCodeAt(0) + 1);
+		if (h > "a") digs.push("0");
+		else digs.pop();
+		return h + digs.join("");
+	} else return head + digs.join("");
+};
+/**
+* @param {string} x
+* @param {string} digits
+* @return {string | null}
+*/
+const decrementInteger = (x, digits) => {
+	validateInteger(x);
+	const [head, ...digs] = x.split("");
+	let borrow = true;
+	for (let i = digs.length - 1; borrow && i >= 0; i--) {
+		const d = digits.indexOf(digs[i]) - 1;
+		if (d === -1) digs[i] = digits.slice(-1);
+		else {
+			digs[i] = digits[d];
+			borrow = false;
+		}
+	}
+	if (borrow) {
+		if (head === "a") return "Z" + digits.slice(-1);
+		if (head === "A") return null;
+		const h = String.fromCharCode(head.charCodeAt(0) - 1);
+		if (h < "Z") digs.push(digits.slice(-1));
+		else digs.pop();
+		return h + digs.join("");
+	} else return head + digs.join("");
+};
+/**
+* @param {string | null} a
+* @param {string | null} b
+* @param {string=} digits
+* @return {string}
+*/
+const generateKeyBetween = (a, b, digits = BASE_62_DIGITS) => {
+	if (a !== null) validateOrderKey(a);
+	if (b !== null) validateOrderKey(b);
+	if (a !== null && b !== null && a >= b) throw new Error(a + " >= " + b);
+	if (a === null) {
+		if (b === null) return INTEGER_ZERO;
+		const ib$1 = getIntegerPart(b);
+		const fb$1 = b.slice(ib$1.length);
+		if (ib$1 === SMALLEST_INTEGER) return ib$1 + midpoint("", fb$1, digits);
+		if (ib$1 < b) return ib$1;
+		const res = decrementInteger(ib$1, digits);
+		if (res === null) throw new Error("cannot decrement any more");
+		return res;
+	}
+	if (b === null) {
+		const ia$1 = getIntegerPart(a);
+		const fa$1 = a.slice(ia$1.length);
+		const i$1 = incrementInteger(ia$1, digits);
+		return i$1 === null ? ia$1 + midpoint(fa$1, null, digits) : i$1;
+	}
+	const ia = getIntegerPart(a);
+	const fa = a.slice(ia.length);
+	const ib = getIntegerPart(b);
+	const fb = b.slice(ib.length);
+	if (ia === ib) return ia + midpoint(fa, fb, digits);
+	const i = incrementInteger(ia, digits);
+	if (i === null) throw new Error("cannot increment any more");
+	if (i < b) return i;
+	return ia + midpoint(fa, null, digits);
+};
+
+//#endregion
+//#region src/paths/array-keys.ts
+/**
+* In the system you are using, two types of keys are used to identify elements in an array: ID keys and position keys.
+* These keys provide a flexible and robust way to refer to specific elements in an array, particularly when dealing with arrays of objects.
+*
+* 1. **ID Keys:**
+* These keys have a prefix of 'id:' and are followed by the unique identifier of an object in the array.
+* For example, in your array `items: [{ id: 'xxx', name: 'John' }]`, you can refer to the object with `id: 'xxx'` using the ID key 'id:xxx'.
+* This is particularly useful when you have a unique identifier for each object in your array.
+* With this, even if objects move around in the array, you can always accurately refer to a specific object using its unique ID.
+*
+* 2. **Position Keys:**
+* These keys have a prefix of 'pos:' and are followed by a position indicator.
+* Position keys provide a way to refer to an object in an array based on its position rather than its content.
+* This can be useful when the position of an object in an array is significant and you want to refer to an object based on where it is in the array.
+*
+* In your path system, you can use either type of key as part of the path to refer to specific elements in an array.
+* For example, if you have an object like `{ items: [{ id: 'xxx', name: 'John' }] }`,
+* you can refer to the name of the first item in the array using either an ID key or a position key in the path:
+*
+* - Using an ID key: `['items', 'id:xxx', 'name']`
+* - Using a position key: `['items', 'pos:0', 'name']`
+*
+* This system of using ID and position keys in paths gives you a powerful and flexible way to refer to specific elements in complex, nested objects.
+*/
+const POSITION_ARRAY_KEY_PREFIX = "pos:";
+/**
+* Checks if the given key is a position array key.
+* @param {unknown} key - The key to check.
+* @returns {boolean} Returns true if `key` is a position array key, false otherwise.
+* @example
+* isPositionArrayKey('pos:0');  // Returns true
+* isPositionArrayKey('id:0');  // Returns false
+*/
+const isPositionArrayKey = (key) => {
+	return isString(key) && key.startsWith(POSITION_ARRAY_KEY_PREFIX);
+};
+/**
+* Creates a position array key.
+* @param {string} position - The position to create the key for.
+* @returns {string} Returns the created position array key.
+* @example
+* createPositionArrayKey('0');  // Returns 'pos:0'
+*/
+const createPositionArrayKey = (position) => {
+	return `${POSITION_ARRAY_KEY_PREFIX}${position}`;
+};
+/**
+* Extracts the position from a position array key.
+* @param {string} key - The position array key to extract the position from.
+* @returns {string} Returns the extracted position.
+* @example
+* extractPositionFromArrayKey('pos:0');  // Returns '0'
+*/
+const extractPositionFromArrayKey = (key) => {
+	if (!isPositionArrayKey(key)) throw new Error(`Invalid array key ${key}. Must be "pos:xxxxx"`);
+	return key.split(POSITION_ARRAY_KEY_PREFIX)[1];
+};
+const ID_PATH_KEY_PREFIX = "id:";
+/**
+* Checks if the given key is an ID array key.
+* @param {unknown} key - The key to check.
+* @returns {boolean} Returns true if `key` is an ID array key, false otherwise.
+* @example
+* isIdArrayKey('id:123');  // Returns true
+* isIdArrayKey('pos:0');  // Returns false
+*/
+const isIdArrayKey = (key) => {
+	return isString(key) && key.startsWith(ID_PATH_KEY_PREFIX);
+};
+/**
+* Creates an ID array key.
+* @param {string} id - The ID to create the key for.
+* @returns {string} Returns the created ID array key.
+* @example
+* createIdArrayKey('123');  // Returns 'id:123'
+*/
+const createIdArrayKey = (id) => {
+	return `${ID_PATH_KEY_PREFIX}${id}`;
+};
+/**
+* Extracts the ID from an ID array key.
+* @param {string} key - The ID array key to extract the ID from.
+* @returns {string} Returns the extracted ID.
+* @example
+* extractIdFromArrayKey('id:123');  // Returns '123'
+*/
+const extractIdFromArrayKey = (key) => {
+	if (!isIdArrayKey(key)) throw new Error(`Invalid array key ${key}. Must be "id:xxxxx"`);
+	return key.split(ID_PATH_KEY_PREFIX)[1];
+};
+/**
+* Checks if the given key is an array key (either a position array key or an ID array key).
+* @param {unknown} key - The key to check.
+* @returns {boolean} Returns true if `key` is an array key, false otherwise.
+* @example
+* isArrayKey('id:123');  // Returns true
+* isArrayKey('pos:0');  // Returns true
+* isArrayKey('abc');  // Returns false
+*/
+const isArrayKey = (key) => isString(key) && (isPositionArrayKey(key) || isIdArrayKey(key));
+/**
+* Extracts the index from an array key in a given array.
+* @param {unknown} array - The array to extract the index from.
+* @param {string} key - The array key to extract the index from.
+* @returns {number} Returns the extracted index.
+* @example
+* getIndexByArrayKey(['a', 'b', 'c'], 'pos:1');  // Returns 1
+*/
+const getIndexByArrayKey = (array, key) => {
+	if (!Array.isArray(array)) {
+		console.error(`Non-array type`, array);
+		throw new Error(`Can't use array key in non array type (${key})`);
+	}
+	if (!isArrayKey(key)) throw new Error(`Unknown array key type (${key})`);
+	if (array.length === 0) return 0;
+	if (isIdArrayKey(key)) {
+		const id = extractIdFromArrayKey(key);
+		const index = array.findIndex((it) => isObject(it) && it.id === id);
+		if (index === -1) throw new Error(`Can't find index by id ${id} (${key})`);
+		return index;
+	} else if (isPositionArrayKey(key)) {
+		const position = extractPositionFromArrayKey(key);
+		const index = array.findIndex((it) => it.position === position);
+		if (index === -1) throw new Error(`Can't find index by position ${position} (${key})`);
+		return index;
+	}
+	return 0;
+};
+
+//#endregion
+//#region src/paths/basic-ops.ts
+/**
+* Gets a nested property value from an object using a path.
+* @param {NestedRecord | undefined} object - The object to get the value from.
+* @param {(string | number)[]} path - The path to the value in the object.
+* @returns {TValue | undefined} Returns the value at the specified path in the object.
+* @example
+* getFromPath({ items: [{ name: 'John' }] }, ['items', 0, 'name']);  // Returns 'John'
+*/
+const getFromPath = (object, path) => {
+	if (!object) return;
+	if (path.length === 0) return object;
+	return path.reduce((acc, propKey) => {
+		const key = isArrayKey(propKey) ? getIndexByArrayKey(acc, propKey) : propKey;
+		if (isContainerValue(acc) && key in acc) return acc[key];
+	}, object);
+};
+/**
+* Sets a nested property value in a path, creates the path properties if they don't exist.
+* @param {NestedRecord} object - The object to set the value in.
+* @param {(string | number)[]} path - The path to the value in the object.
+* @param {unknown} value - The value to set.
+* @example
+* let obj = { items: [{ name: 'John' }] };
+* setInPath(obj, ['items', 0, 'name'], 'Jane');  // obj is now { items: [{ name: 'Jane' }] }
+*/
+const setInPath = (object, path, value) => {
+	let acc = object;
+	for (const [i, rawKey] of path.entries()) {
+		const key = isArrayKey(rawKey) ? getIndexByArrayKey(acc, rawKey) : rawKey;
+		if (Array.isArray(acc)) {
+			const index = Number(key);
+			if (i === path.length - 1) {
+				acc[index] = value;
+				return;
+			}
+			if (!(index in acc) || isNullOrUndefined(acc[index])) {
+				const nextRawKey = path[i + 1];
+				acc[index] = isIndex(isArrayKey(nextRawKey) ? getIndexByArrayKey(acc, nextRawKey) : nextRawKey) ? [] : {};
+			}
+			acc = acc[index];
+		} else {
+			if (i === path.length - 1) {
+				acc[key] = value;
+				return;
+			}
+			if (!(key in acc) || isNullOrUndefined(acc[key])) {
+				const nextRawKey = path[i + 1];
+				acc[key] = isIndex(isArrayKey(nextRawKey) ? getIndexByArrayKey(acc, nextRawKey) : nextRawKey) ? [] : {};
+			}
+			acc = acc[key];
+		}
+	}
+};
+const unset = (object, key) => {
+	if (Array.isArray(object) && isIndex(key)) {
+		object.splice(Number(key), 1);
+		return;
+	}
+	if (isObject(object)) delete object[key];
+};
+/**
+* Removes a nested property from an object using a path.
+* @param {NestedRecord} object - The object to remove the value from.
+* @param {(string | number)[]} path - The path to the value in the object.
+* @example
+* let obj = { items: [{ name: 'John' }] };
+* unsetPath(obj, ['items', 0, 'name']);  // obj is now { items: [{}] }
+*/
+const unsetPath = (object, path) => {
+	let acc = object;
+	for (const [i, rawKey] of path.entries()) {
+		const key = isArrayKey(rawKey) ? getIndexByArrayKey(acc, rawKey) : rawKey;
+		if (i === path.length - 1) {
+			unset(acc, key);
+			break;
+		}
+		if (Array.isArray(acc)) {
+			const index = Number(key);
+			if (!(key in acc) || isNullOrUndefined(acc[index])) break;
+			acc = acc[index];
+		} else {
+			if (!(key in acc) || isNullOrUndefined(acc[key])) break;
+			acc = acc[key];
+		}
+	}
+};
+/** Checks if a nested property exists in an object using a path.
+* @param {NestedRecord | undefined} object - The object to check the value in.
+* @param {(string | number)[]} path - The path to the value in the object.
+* @returns {boolean} Returns true if the value exists at the specified path, false otherwise.
+* @example
+* existsInPath({ items: [{ name: 'John' }] }, ['items', 0, 'name']);  // Returns true
+* existsInPath({ items: [{ name: 'John' }] }, ['items', 1, 'name']);  // Returns false
+*/
+const existsInPath = (object, path) => {
+	return getFromPath(object, path) !== void 0;
+};
+/** * Compares two paths for equality.
+* @param {(string | number)[]} pathA - The first path to compare.
+* @param {(string | number)[]} pathB - The second path to compare.
+* @returns {boolean} Returns true if the paths are equal, false otherwise.
+* @example
+* isSamePath(['items', 0, 'name'], ['items', 0, 'name']);  // Returns true
+* isSamePath(['items', 0, 'name'], ['items', 1, 'name']);  // Returns false
+*/
+const isSamePath = (pathA, pathB) => {
+	if (pathA.length !== pathB.length) return false;
+	for (let i = 0; i < pathA.length; i++) if (pathA[i] !== pathB[i]) return false;
+	return true;
+};
+
+//#endregion
+//#region src/paths/array-ops.ts
+/**
+* Pushes a value into a nested array in an object using a path.
+* @param {NestedRecord} object - The object to push the value into.
+* @param {(string | number)[]} path - The path to the array in the object.
+* @param {unknown} value - The value to push.
+* @example
+* let obj = { items: ['John'] };
+* pushInPath(obj, ['items'], 'Jane');  // obj is now { items: ['John', 'Jane'] }
+*/
+const pushInPath = (object, path, value) => {
+	const array = getFromPath(object, path);
+	if (!Array.isArray(array)) setInPath(object, path, [value]);
+	else array.push(value);
+};
+/**
+* Inserts values into a nested array in an object at a specified index or key using a path.
+* @param {NestedRecord} object - The object to insert the values into.
+* @param {(string | number)[]} path - The path to the array in the object.
+* @param {string | number} keyOrIndex - The index or key at which to insert the values.
+* @param {unknown[]} values - The values to insert.
+* @example
+* let obj = { items: ['John', 'Jane'] };
+* insertInPath(obj, ['items'], 1, ['Joe']);  // obj is now { items: ['John', 'Joe', 'Jane'] }
+*/
+const insertInPath = (object, path, keyOrIndex, values) => {
+	const array = getFromPath(object, path);
+	if (Array.isArray(array)) {
+		if (isIndex(keyOrIndex)) array.splice(keyOrIndex, 0, ...values);
+		else if (isArrayKey(keyOrIndex)) {
+			const index = getIndexByArrayKey(array, keyOrIndex);
+			array.splice(index, 0, ...values);
+		}
+	}
+};
+/**
+* Removes a value from a nested array in an object at a specified index or array key using a path.
+* @param {NestedRecord} object - The object to remove the value from.
+* @param {(string | number)[]} path - The path to the array in the object.
+* @param {string | number} key - The index or key at which to remove the value.
+* @example
+* let obj = { items: ['John', 'Joe', 'Jane'] };
+* pullFromPath(obj, ['items'], 1);  // obj is now { items: ['John', 'Jane'] }
+*/
+const pullFromPath = (object, path, key) => {
+	const array = getFromPath(object, path);
+	if (Array.isArray(array)) {
+		if (isIndex(key)) array.splice(key, 1);
+		else if (isArrayKey(key)) {
+			const index = getIndexByArrayKey(array, key);
+			array.splice(index, 1);
+		}
+	}
+};
+const printPosition$1 = (array) => array.map((it) => isObject(it) ? it.position ?? "no-position" : "not-object");
+/**
+* Moves an item to a new position relative to another item in the array or object at the specified path.
+*
+* @example
+* moveInYPath(values, ['components'], 'a0', 'b1', 'after');
+*/
+const moveInPath = (object, path, oldPosition, relativePosition, insert) => {
+	const array = getFromPath(object, path);
+	if (!Array.isArray(array)) throw new Error(`Can't move. Target item is not array in path ${JSON.stringify(path)}`);
+	const item = array.find((it) => isObject(it) && it.position === oldPosition);
+	const relativeItemIndex = array.findIndex((it) => isObject(it) && it.position === relativePosition);
+	if (!isObject(item)) throw new Error(`Can't move. Item in position ${oldPosition} not found. ${printPosition$1(array)}`);
+	if (relativeItemIndex === -1) throw new Error(`Can't move. Relative item in position ${relativePosition} not found. ${printPosition$1(array)}`);
+	const relativeItem = array[relativeItemIndex];
+	if (!isObject(relativeItem)) throw new Error(`Can't move. Relative item in position ${relativePosition} must be an object. ${printPosition$1(array)}`);
+	if (insert === "before") {
+		const left = array[relativeItemIndex - 1];
+		const newPosition$1 = generateKeyBetween(isObject(left) ? left.position ?? null : null, relativeItem.position);
+		item.position = newPosition$1;
+		return newPosition$1;
+	}
+	const right = array[relativeItemIndex + 1];
+	const rightPosition = isObject(right) ? right.position ?? null : null;
+	const newPosition = generateKeyBetween(relativeItem.position, rightPosition);
+	item.position = newPosition;
+	return newPosition;
+};
+
+//#endregion
+//#region src/paths/constants.ts
+const PATH_REGEXP = /\.|\[(\d+)\]/;
+
+//#endregion
+//#region src/paths/tools.ts
+/**
+* Joins a path with additional items.
+* @param {(string | number)[]} path - The initial path.
+* @param {...(string | number)[]} items - The items to add to the path.
+* @returns {(string | number)[]} Returns the joined path.
+* @throws {Error} If `path` is not an array or if any of `items` are not a string or an integer.
+* @example
+* joinPath(['items', 'id:xxx'], 'name');  // Returns ['items', 'id:xxx', 'name']
+*/
+const joinPath = (path, ...items) => {
+	if (!Array.isArray(path)) throw new Error(`path must be array: ${path}`);
+	for (const item of items) if (!isString(item) && !Number.isInteger(item)) throw new Error(`Invalid path item: ${item}`);
+	return path.concat(items);
+};
+/**
+* Compares two fractional-based position strings for sorting.
+* @param {string} aPosition - The first fractional-based position string.
+* @param {string} bPosition - The second fractional-based position string.
+* @returns {number} Returns -1 if `aPosition` comes before `bPosition`, 1 if `aPosition` comes after `bPosition`, or 0 if they are equal.
+* @example
+* sortByPosition('a1', 'a2');  // Returns -1
+*/
+const sortByPosition = (aPosition, bPosition) => {
+	if (aPosition < bPosition) return -1;
+	else if (aPosition > bPosition) return 1;
+	return 0;
+};
+
+//#endregion
+//#region src/dynamic-components/registry/chats.ts
+const isChatTextMessageComponent = (component) => component.component === "chat-text-message";
+const isChatMessageDelayComponent = (component) => component.component === "chat-message-delay";
+
+//#endregion
+//#region src/dynamic-components/registry/content.ts
+const isRichTextComponent = (component) => component.component === "rich-text";
+const isEmbedCodeComponent = (component) => {
+	return component.component === "embed-code";
+};
+const isImageComponent = (component) => component.component === "image";
+const isLegacyContentComponent = (component) => component.component === "legacy-content";
+const isBibleQuoteComponent = (component) => component.component === "bible-quote";
+const isBiblePassageComponent = (component) => component.component === "bible-passage";
+const isTestComponent = (component) => component.component === "test";
+const isStatementComponent = (component) => component.component === "statement";
+const isPracticeComponent = (component) => component.component === "practice";
+
+//#endregion
+//#region src/dynamic-components/registry/forms.ts
+let IImageRenditionType = /* @__PURE__ */ function(IImageRenditionType$1) {
+	IImageRenditionType$1["ORIGINAL"] = "ORIGINAL";
+	IImageRenditionType$1["MAIN_2X"] = "MAIN_2X";
+	IImageRenditionType$1["MAIN"] = "MAIN";
+	IImageRenditionType$1["SMALL"] = "SMALL";
+	IImageRenditionType$1["MAIN_LEGACY"] = "MAIN_LEGACY";
+	return IImageRenditionType$1;
+}({});
+const isComputedValueComponent = (component) => component.component === "computed-value";
+const isTextInputComponent = (component) => component.component === "text-input";
+const isConfirmDeletionInputComponent = (component) => component.component === "confirm-deletion-input";
+const isTextareaComponent = (component) => component.component === "textarea";
+const isHeadingComponent = (component) => component.component === "heading";
+const isRichTextEditorComponent = (component) => component.component === "rich-text-editor";
+const isDateTimePickerComponent = (component) => {
+	return component.component === "date-time-picker";
+};
+const isNumberInputComponent = (component) => {
+	return component.component === "number-input";
+};
+const isSlugComponent = (component) => {
+	return component.component === "slug";
+};
+const isImageUploaderComponent = (component) => {
+	return component.component === "image-uploader";
+};
+const isRawImageUploaderComponent = (component) => {
+	return component.component === "raw-image-uploader";
+};
+const isRawImagesUploaderComponent = (component) => {
+	return component.component === "raw-images-uploader";
+};
+const isSimpleImageUploaderComponent = (component) => {
+	return component.component === "simple-image-uploader";
+};
+const isRadioGroupComponent = (component) => {
+	return component.component === "radio-group";
+};
+const isSelectComponent = (cmp) => cmp.component === "select";
+const isEntitySelectComponent = (cmp) => cmp.component === "entity-select";
+const isCheckboxComponent = (component) => {
+	return component.component === "checkbox";
+};
+const isCheckboxGroupComponent = (component) => {
+	return component.component === "checkbox";
+};
+const isSwitchComponent = (component) => {
+	return component.component === "switch";
+};
+const isFileUploaderComponent = (component) => {
+	return component.component === "file-uploader";
+};
+
+//#endregion
+//#region src/dynamic-components/registry/layout.ts
+const isColumnComponent = (component) => {
+	return component.component === "column";
+};
+const isRowComponent = (component) => {
+	return component.component === "row";
+};
+const isCollectionComponent = (component) => {
+	return component.component === "collection";
+};
+const isRepeatableCollectionComponent = (component) => {
+	return component.component === "repeatable-collection";
+};
+const isRowSettingsComponent = (component) => {
+	return component.component === "row-settings";
+};
+
+//#endregion
+//#region src/dynamic-components/paths.ts
+/**
+* Get array with components founded by rpath
+*
+* @example
+* const components = [
+*  {
+*    id: "xxx",
+*    component: "collection",
+*    props: {
+*      components: [
+*        {
+*           id: "yyy",
+*           component: "text-input",
+*           props: {
+*             label: "Title"
+*           }
+*        }
+*      ]
+*    }
+*  }
+* ]
+*
+* const { pathWithComponents } = getComponentsSubtreeByRPath(components, ['xxx', 'yyy']);
+*
+* // pathWithComponents
+* // [
+* //   {
+* //     id: "xxx",
+* //     component: "collection",
+* //     ...
+* //   },
+* //   {
+* //     id: "yyy",
+* //     component: "text-input",
+* //     ...
+* //  }
+* // ]
+*
+*/
+const getComponentsSubtreeByRPath = (components, rpath) => {
+	const pathWithComponents = [];
+	deepGetComponentsSubtreeByRPath(components, rpath, pathWithComponents);
+	return {
+		pathWithComponents,
+		complete: pathWithComponents.length === rpath.length
+	};
+};
+const deepGetComponentsSubtreeByRPath = (components, rpath, pathWithComponents) => {
+	const id = rpath[0];
+	const component = components.find((cmp) => cmp.id === id);
+	if (!component) return;
+	pathWithComponents.push(component);
+	if (!Array.isArray(component.props.components)) return;
+	deepGetComponentsSubtreeByRPath(component.props.components, rpath.slice(1), pathWithComponents);
+};
+/**
+* Get array with components founded by values path.
+*
+* @example
+* const components = [
+*  {
+*    id: "xxx",
+*    component: "collection",
+*    props: {
+*      name: "seo",
+*      components: [
+*        {
+*           id: "yyy",
+*           component: "text-input",
+*           props: {
+*             label: "Title",
+*             name: "title",
+*           }
+*        }
+*      ]
+*    }
+*  }
+* ]
+*
+* const { pathWithComponents } = getComponentsSubtreeByPath(components, ['seo', 'title']);
+*
+* // pathWithComponents
+* // [
+* //   {
+* //     id: "xxx",
+* //     component: "collection",
+* //     ...
+* //   },
+* //   {
+* //     id: "yyy",
+* //     component: "text-input",
+* //     ...
+* //  }
+* // ]
+*
+*/
+const getComponentsSubtreeByPath = (components, path) => {
+	const pathWithComponents = [];
+	const complete = true;
+	deepGetComponentsSubtreeByPath(components, path, pathWithComponents, complete);
+	return {
+		pathWithComponents,
+		complete
+	};
+};
+const deepFindComponentPathKey = (components, key) => {
+	for (const component of components) {
+		if (component.props.name && component.props.name === key || component.id === key) return component;
+		if (isRowComponent(component) || isColumnComponent(component)) {
+			const result = deepFindComponentPathKey(component.props.components, key);
+			if (result) return result;
+		}
+	}
+	return null;
+};
+const deepGetComponentsSubtreeByPath = (components, path, pathWithComponents, complete) => {
+	const key = path[0];
+	if (!isString(key)) {
+		complete = false;
+		return;
+	}
+	const component = deepFindComponentPathKey(components, key);
+	if (!component) {
+		complete = false;
+		return;
+	}
+	pathWithComponents.push(component);
+	/**
+	* Deep dive if repeatable collection.
+	*
+	* If next key is array key find in props.components next key after array key
+	*
+	* @example
+	* path = ['fields', 'id:xxx', 'title']
+	*
+	* cpnst key = 'fields';
+	* const nextKey = 'id:xxx', // array key
+	* const nextKeyAfterArrayKey = 'title';
+	*/
+	if (isRepeatableCollectionComponent(component)) {
+		const nextKey = path[1];
+		if (isArrayKey(nextKey) && path[2]) deepGetComponentsSubtreeByPath(component.props.components, path.slice(2), pathWithComponents, complete);
+	}
+	if (isCollectionComponent(component)) deepGetComponentsSubtreeByPath(component.props.components, path.slice(1), pathWithComponents, complete);
+};
+
+//#endregion
+//#region src/dynamic-components/tools.ts
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+const customAlphabet = (alphabet, defaultSize = 21) => {
+	return (size = defaultSize) => {
+		let id = "";
+		let i = size;
+		while (i--) id += alphabet[Math.random() * alphabet.length | 0];
+		return id;
+	};
+};
+const uid = customAlphabet("1234567890abcdefg", 5);
+/**
+* Gets the path to a property in a component.
+* @param {(string | number)[]} componentPath - The path to the component.
+* @param {string} name - The name of the property.
+* @returns {(string | number)[]} Returns the path to the property.
+* @example
+* getComponentPropertyPath(['components', 0], 'name');  // Returns ['components', 0, 'props', 'name']
+*/
+const getComponentPropertyPath = (componentPath, name) => [
+	...componentPath,
+	"props",
+	name
+];
+/**
+* Creates a copy of a dynamic component.
+* @param {DynamicComponent} component - The component to copy.
+* @param {Y.Doc} yDoc - The Yjs document to update with the copied component.
+* @returns {DynamicComponent} Returns the copied component.
+*/
+const copyDynamicComponent = (component, yDoc) => {
+	const { id, props, coordinates, inputs, outputs,...extras } = component;
+	const componentCopy = {
+		...extras,
+		id: uid(),
+		props: {}
+	};
+	if (coordinates) componentCopy.coordinates = [coordinates[0] + 10, coordinates[1] + 10];
+	if (inputs) componentCopy.inputs = inputs.map((input) => ({
+		...input,
+		id: uid()
+	}));
+	if (outputs) componentCopy.outputs = outputs.map((output) => ({
+		...output,
+		id: uid()
+	}));
+	for (const [key, value] of Object.entries(props)) if (key === "components" && Array.isArray(value)) componentCopy.props.components = value.map((cmp) => copyDynamicComponent(cmp));
+	else if (isRichText(value)) {
+		const oldKey = `${value.type}:${value.id}`;
+		const newRichText = {
+			...value,
+			id: uid()
+		};
+		const newKey = `${value.type}:${newRichText.id}`;
+		if (yDoc) {
+			const yXmlFragment = yDoc.getXmlFragment(oldKey);
+			const newYXmlFragment = yDoc.getXmlFragment(newKey);
+			const clones = [];
+			for (const item of yXmlFragment.toArray()) if (item instanceof Y.XmlElement || item instanceof Y.XmlText) clones.push(item.clone());
+			newYXmlFragment.insert(0, clones);
+		}
+		componentCopy.props[key] = newRichText;
+	} else componentCopy.props[key] = value;
+	return componentCopy;
+};
+/**
+* Sorts an array of dynamic components and generates a position for each one.
+* @param {DynamicComponent[]} components - The components to sort.
+* @returns {DynamicComponentWithPosition[]} Returns the sorted components with positions.
+*/
+const sortDynamicComponents = (components) => {
+	return components.reduce((acc, component, i) => {
+		const prev = acc[i - 1];
+		const { position, props: { components: components$1,...baseProps },...baseFields } = component;
+		const props = baseProps;
+		if (components$1) props.components = sortDynamicComponents(components$1);
+		acc.push({
+			...baseFields,
+			position: position ?? generateKeyBetween(prev?.position ?? null, null),
+			props
+		});
+		return acc;
+	}, []);
+};
+/**
+* Searches for a dynamic component in a tree that matches a condition.
+* @param {DynamicComponent[]} components - The tree of components to search.
+* @param {(cmp: DynamicComponent) => boolean} isMatches - The condition to match.
+* @returns {DynamicComponent | null} Returns the matching component, or null if no match was found.
+*/
+const searchDynamicComponentInTree = (components, isMatches) => {
+	for (const component of components) {
+		if (isMatches(component)) return component;
+		if (Array.isArray(component.props.components)) {
+			const result = searchDynamicComponentInTree(component.props.components, isMatches);
+			if (result) return result;
+		}
+	}
+	return null;
+};
+const getRelativePoint = (point, relative) => [point[0] - relative[0], point[1] - relative[1]];
+/**
+* Creates a copy of a dynamic component and set its position (fractional-index) rely on the index of the component.
+* @param components - The components without positions.
+*/
+const makeDynamicComponentsWithPosition = (components) => {
+	return sortDynamicComponents(components.slice(0));
+};
+
+//#endregion
+//#region src/dynamic-components/types.ts
+/**
+* Defines a DynamicComponent.
+* @param {T} component - The component to define.
+* @returns {T} Returns the defined component.
+*/
+const defineDynamicComponent = (component) => component;
+/**
+* Defines an array of DynamicComponents.
+* @param {T[]} components - The components to define.
+* @returns {T[]} Returns the defined components.
+*/
+const defineDynamicComponents = (components) => components.map((component) => defineDynamicComponent(component));
+
+//#endregion
+//#region src/y-tools/y-array-keys.ts
+/**
+* Returns the index of an item in a Y.Array based on its key.
+* The key can represent either the id or the position of the item in the array.
+*
+* @example
+* let yArray = new Y.Array();
+* let yMap = new Y.Map();
+* yMap.set('id', '123');
+* yMap.set('position', 'a0');
+* yArray.push([yMap]);
+* const index = getYArrayIndexByArrayKey(yArray, 'id:123');
+* const index = getYArrayIndexByArrayKey(yArray, 'pos:a0');
+* // index is now: 0
+*/
+const getYArrayIndexByArrayKey = (yArray, key) => {
+	if (!isYArray(yArray)) {
+		console.error(`Non-YArray type`, yArray);
+		throw new Error(`Can't use array key in non YArray type (${key})`);
+	}
+	if (isIdArrayKey(key)) {
+		const id = extractIdFromArrayKey(key);
+		const index = yArray.toArray().findIndex((it) => isYMap(it) && it.get("id") === id);
+		if (index === -1) throw new Error(`Can't find index by id ${id} (${key})`);
+		return index;
+	} else if (isPositionArrayKey(key)) {
+		const position = extractPositionFromArrayKey(key);
+		const index = yArray.toArray().findIndex((it) => isYMap(it) && it.get("position") === position);
+		if (index === -1) throw new Error(`Can't find index by position ${position} (${key})`);
+		return index;
+	}
+	throw new Error(`Unknown array key type (${key})`);
+};
+
+//#endregion
+//#region src/y-tools/basic-path-ops.ts
+/**
+* Sets a value at a given path within a Y.Map or Y.Array.
+*
+* @example
+* let ymap = new Y.Map();
+* setInYPath(ymap, ['key'], 'value');
+* // ymap now looks like: { key: 'value' }
+*/
+const setInYPath = (ymap, path, value) => {
+	let acc = ymap;
+	for (const [i, rawKey] of path.entries()) {
+		const key = isArrayKey(rawKey) ? getYArrayIndexByArrayKey(acc, rawKey) : rawKey;
+		if (isYArray(acc) && isIndex(key)) {
+			const index = key;
+			if (i === path.length - 1) {
+				acc.delete(index);
+				acc.push([value]);
+				return;
+			}
+			if (isNullOrUndefined(acc.get(index))) {
+				const nextRawKey = path[i + 1];
+				const nextKey = isArrayKey(nextRawKey) ? getYArrayIndexByArrayKey(acc, nextRawKey) : nextRawKey;
+				acc.delete(index);
+				acc.insert(index, [isIndex(nextKey) ? new Y.Array() : new Y.Map()]);
+			}
+			acc = acc.get(index);
+		} else if (isYMap(acc) && isString(key)) {
+			if (i === path.length - 1) {
+				acc.set(key, value);
+				return;
+			}
+			if (!acc.has(key) || isNullOrUndefined(acc.get(key))) {
+				const nextRawKey = path[i + 1];
+				const nextKey = isArrayKey(nextRawKey) ? getYArrayIndexByArrayKey(acc, nextRawKey) : nextRawKey;
+				acc.set(key, isIndex(nextKey) ? new Y.Array() : new Y.Map());
+			}
+			acc = acc.get(key);
+		}
+	}
+};
+const yUnset = (yType, key) => {
+	if (yType instanceof Y.Array && isIndex(key)) yType.delete(Number(key));
+	else if (yType instanceof Y.Map && isString(key)) yType.delete(key);
+};
+/**
+* Removes a nested property from a Y.Map or Y.Array.
+*
+* @example
+* let ymap = new Y.Map();
+* ymap.set('key', 'value');
+* unsetYPath(ymap, ['key']);
+* // ymap now looks like: {}
+*/
+const unsetYPath = (yType, path) => {
+	let acc = yType;
+	for (const [i, rawKey] of path.entries()) {
+		const key = isArrayKey(rawKey) ? getYArrayIndexByArrayKey(acc, rawKey) : rawKey;
+		if (i === path.length - 1) {
+			yUnset(acc, key);
+			break;
+		}
+		if (acc instanceof Y.Array && isIndex(key)) {
+			const index = Number(key);
+			if (isNullOrUndefined(acc.get(index))) break;
+			acc = acc.get(index);
+		} else if (acc instanceof Y.Map && isString(key)) {
+			if (!acc.has(key) || isNullOrUndefined(acc.get(key))) break;
+			acc = acc.get(key);
+		}
+	}
+};
+/**
+* Retrieves a nested property value from a Y.Map or Y.Array.
+*
+* @example
+* let ymap = new Y.Map();
+* ymap.set('key', 'value');
+* const value = getFromYPath(ymap, ['key']);
+* // value is now: 'value'
+*/
+const getFromYPath = (entry, path) => {
+	if (!entry) return;
+	if (path.length === 0) return entry;
+	let ref = entry;
+	for (const rawKey of path) {
+		const key = isArrayKey(rawKey) ? getYArrayIndexByArrayKey(ref, rawKey) : rawKey;
+		if (isYArray(ref)) {
+			if (!isIndex(key)) {
+				console.warn(`Can't use non index key in YArray ${key}: ${JSON.stringify(path)}`);
+				return null;
+			}
+			ref = ref.get(key);
+			continue;
+		} else if (isYMap(ref)) {
+			if (!isString(key)) {
+				console.warn(`Can't use non string key in YMap ${key}: ${JSON.stringify(path)}`);
+				return null;
+			}
+			ref = ref.get(key);
+		} else {
+			console.warn(`Non supported YType on ${key}: ${JSON.stringify(path)}`);
+			return null;
+		}
+	}
+	return ref;
+};
+
+//#endregion
+//#region src/y-tools/tools.ts
+/**
+* Returns the index of the first item in a Y.Array that matches a condition.
+*
+* @example
+* let yArray = new Y.Array();
+* yArray.push(['item1', 'item2', 'item3']);
+* const index = findIndexInYArray(yArray, (item) => item === 'item2');
+* // index is now: 1
+*/
+const findIndexInYArray = (yArray, isMatches) => {
+	return yArray.toArray().findIndex(isMatches);
+};
+/**
+* Returns the first item in a Y.Array that matches a condition.
+*
+* @example
+* let yArray = new Y.Array();
+* yArray.push(['item1', 'item2', 'item3']);
+* const item = findInYArray(yArray, (item) => item === 'item2');
+* // item is now: 'item2'
+*/
+const findInYArray = (yArray, isMatches) => {
+	const index = findIndexInYArray(yArray, isMatches);
+	if (index === -1) return null;
+	return yArray.get(index);
+};
+/**
+* Converts an object to a Y.Map.
+*
+* @example
+* const object = { key: 'value' };
+* const yMap = objectToYMap(object);
+* // yMap now looks like: { key: 'value' }
+*/
+const objectToYMap = (values) => {
+	const entries = Object.entries(values).map(([key, value]) => {
+		if (Array.isArray(value)) return [key, arrayToYArray(value)];
+		else if (isObject(value)) return [key, objectToYMap(value)];
+		else return [key, value];
+	});
+	return new Y.Map(entries);
+};
+/**
+* Converts an array to a Y.Array.
+*
+* @example
+* const array = ['item1', 'item2', 'item3'];
+* const yArray = arrayToYArray(array);
+* // yArray now looks like: ['item1', 'item2', 'item3']
+*/
+const arrayToYArray = (array, yArray = new Y.Array()) => {
+	const items = array.map((it) => isObject(it) ? objectToYMap(it) : it);
+	yArray.insert(0, items);
+	return yArray;
+};
+/**
+* Returns a sorted Y.Array based on the position of each Y.Map in it.
+*
+* @example
+* let yArray = new Y.Array();
+* let yMap1 = new Y.Map();
+* let yMap2 = new Y.Map();
+* yMap1.set('position', 'a0');
+* yMap2.set('position', 'b0');
+* yArray.push([yMap2, yMap1]);
+* const sortedYArray = getSortedYArray(yArray);
+* // sortedYArray now looks like: [ yMap1, yMap2 ]
+*/
+const getSortedYArray = (yArray) => yArray.toArray().sort((a, b) => sortByPosition(a.get("position"), b.get("position")));
+/**
+* Returns references to a Y.Map and its neighbors in a Y.Array based on its position.
+*
+* @example
+* let yArray = new Y.Array();
+* let yMap1 = new Y.Map();
+* let yMap2 = new Y.Map();
+* yMap1.set('position', 'a0');
+* yMap2.set('position', 'b0');
+* yArray.push([yMap2, yMap1]);
+* const refs = getYArrayRefsByPosition(yArray, 'a0');
+* // refs now looks like: { index: 0, ref: yMap1, right: yMap2, left: undefined, sortedArray: [yMap1, yMap2] }
+*/
+const getYArrayRefsByPosition = (yArray, position) => {
+	const sortedArray = getSortedYArray(yArray);
+	const index = sortedArray.findIndex((it) => it.get("position") === position);
+	if (index === -1) {
+		console.error("sortedArray", sortedArray);
+		throw new Error(`Relative item with position ${position} not found`);
+	}
+	return {
+		index,
+		ref: sortedArray[index],
+		right: sortedArray[index + 1],
+		left: sortedArray[index - 1],
+		sortedArray
+	};
+};
+
+//#endregion
+//#region src/y-tools/array-path-ops.ts
+/**
+* Pushes a value to the end of the Y.Array at the specified path.
+*
+* @example
+* let yMap = new Y.Map();
+* yMap.set('names', new Y.Array());
+* pushInYPath(yMap, ['names'], 'John');
+* // yMap now looks like: { names: ['John'] }
+*/
+const pushInYPath = (entry, path, value) => {
+	const yArray = getFromYPath(entry, path);
+	if (!isYArray(yArray)) setInYPath(entry, path, Y.Array.from([value]));
+	else yArray.push([value]);
+};
+const printPosition = (array) => array.map((it) => isYMap(it) ? it.get("position") ?? "no-position" : "not-ymap");
+/**
+* Moves an item to a new position relative to another item in the Y.Array or Y.Map at the specified path.
+*
+* @example
+* moveInYPath(yMap, ['components'], 'a0', 'b1', 'after');
+*/
+const moveInYPath = (entry, path, oldPosition, relativePosition, insert) => {
+	const yArray = getFromYPath(entry, path);
+	if (!isYArray(yArray)) throw new Error(`Can't move. Target item is not yArray in path ${JSON.stringify(path)}`);
+	const array = yArray.toArray();
+	const item = array.find((it) => isYMap(it) && it.get("position") === oldPosition);
+	const relativeItemIndex = array.findIndex((it) => isYMap(it) && it.get("position") === relativePosition);
+	if (!isYMap(item)) throw new Error(`Can't move. Item in position ${oldPosition} not found. ${printPosition(array)}`);
+	if (relativeItemIndex === -1) throw new Error(`Can't move. Relative item in position ${relativePosition} not found. ${printPosition(array)}`);
+	const relativeItem = array[relativeItemIndex];
+	if (!isYMap(relativeItem)) throw new Error(`Can't move. Relative item in position ${relativePosition} must be YMap. ${printPosition(array)}`);
+	if (insert === "before") {
+		const left = array[relativeItemIndex - 1];
+		const newPosition$1 = generateKeyBetween(isYMap(left) ? left.get("position") ?? null : null, relativeItem.get("position"));
+		item.set("position", newPosition$1);
+		return newPosition$1;
+	}
+	const right = array[relativeItemIndex + 1];
+	const rightPosition = isYMap(right) ? right.get("position") ?? null : null;
+	const newPosition = generateKeyBetween(relativeItem.get("position"), rightPosition);
+	item.set("position", newPosition);
+	return newPosition;
+};
+/**
+* Removes an item from the Y.Array or Y.Map at the specified path.
+*
+* @example
+* let yArray = new Y.Array();
+* yArray.push(['item1', 'item2', 'item3']);
+* pullFromYPath(yArray, [1]);
+* // yArray now looks like: ['item1', 'item3']
+*/
+const pullFromYPath = (entry, path, key) => {
+	const yArray = getFromYPath(entry, path);
+	if (isYArray(yArray)) {
+		if (isIndex(key)) {
+			yArray.delete(key);
+			return;
+		}
+		const index = getYArrayIndexByArrayKey(yArray, key);
+		yArray.delete(index);
+	}
+};
+/**
+* Moves a Y.Map to the start of a Y.Array.
+* */
+const moveYMapToStart = ({ yArray, yMap }) => {
+	const first = getSortedYArray(yArray)[0];
+	const rightIndex = first ? first.get("position") : null;
+	yMap.set("position", generateKeyBetween(null, rightIndex));
+};
+/**
+* Moves a Y.Map to the end of a Y.Array.
+* */
+const moveYMapToEnd = ({ yArray, yMap }) => {
+	const sortedArray = getSortedYArray(yArray);
+	const last = sortedArray[sortedArray.length - 1];
+	const leftIndex = last ? last.get("position") : null;
+	yMap.set("position", generateKeyBetween(leftIndex, null));
+};
+/**
+* Moves a Y.Map before another Y.Map in a Y.Array.
+* */
+const moveYMapBefore = ({ yArray, yMap, relativePosition }) => {
+	const { ref: relative, left } = getYArrayRefsByPosition(yArray, relativePosition);
+	const right = relative;
+	const rightIndex = right ? right.get("position") : null;
+	const leftIndex = left ? left.get("position") : null;
+	yMap.set("position", generateKeyBetween(leftIndex, rightIndex));
+};
+/**
+* Moves a Y.Map after another Y.Map in a Y.Array.
+* */
+const moveYMapAfter = ({ yArray, yMap, relativePosition }) => {
+	const { ref: relative, right } = getYArrayRefsByPosition(yArray, relativePosition);
+	const left = relative;
+	const rightIndex = right ? right.get("position") : null;
+	const leftIndex = left ? left.get("position") : null;
+	yMap.set("position", generateKeyBetween(leftIndex, rightIndex));
+};
+/**
+* Inserts a Y.Map to the end of a Y.Array.
+* */
+const insertYMapToEnd = (opts) => {
+	moveYMapToEnd(opts);
+	opts.yArray.push([opts.yMap]);
+};
+/**
+* Inserts a Y.Map before another Y.Map in a Y.Array.
+* */
+const insertYMapBefore = (opts) => {
+	moveYMapBefore(opts);
+	opts.yArray.push([opts.yMap]);
+};
+/**
+* Inserts a Y.Map before another Y.Map in a Y.Array.
+* */
+const insertYMapAfter = (opts) => {
+	moveYMapAfter(opts);
+	opts.yArray.push([opts.yMap]);
+};
+
+//#endregion
+//#region src/y-components/tools.ts
+/**
+* This function converts dynamic component properties to Y.Map representation.
+*/
+const dynamicComponentPropsToYComponentProps = (props) => {
+	const entries = Object.entries(props).map(([key, value]) => {
+		if (key === "content" && isObject(value) && value.content?.type === "doc") return [key, value.content];
+		else if (Array.isArray(value)) return [key, arrayToYArray(value)];
+		else if (isObject(value)) return [key, objectToYMap(value)];
+		else return [key, value];
+	});
+	return new Y.Map(entries);
+};
+/**
+* This function converts a dynamic component to Y.Map representation.
+*/
+const dynamicComponentToYMap = (component, yMap = new Y.Map()) => {
+	const { props: propsWithComponents,...fields } = component;
+	const { components,...props } = propsWithComponents ?? {};
+	for (const [key, value] of Object.entries(fields)) yMap.set(key, value);
+	const yProps = props ? objectToYMap(props) : new Y.Map();
+	if (Array.isArray(components)) yProps.set("components", dynamicComponentsToYArray(components));
+	yMap.set("props", yProps);
+	return yMap;
+};
+/**
+* This function converts an array of dynamic components to Y.Array representation.
+*/
+const dynamicComponentsToYArray = (components, yArray = new Y.Array()) => {
+	yArray.push(sortDynamicComponents(components).map((cmp) => dynamicComponentToYMap(cmp)));
+	return yArray;
+};
+/**
+* This function checks if a given Y.Map object is a YComponent.
+*/
+const isYComponent = (yComponent) => {
+	return isYMap(yComponent) && isString(yComponent.get("component")) && isString(yComponent.get("id"));
+};
+/**
+* This function converts a YComponent to a dynamic component.
+*/
+const yComponentToDynamicComponent = (yComponent, extractContent = false) => {
+	const component = { props: {} };
+	for (const [key, value] of yComponent.entries()) if (key === "props") {
+		if (!isYMap(value)) throw new Error("Component props must be YMap");
+		const yComponentProps = value;
+		const props = {};
+		for (const [prop, value$1] of yComponentProps.entries()) if (prop === "components") {
+			if (!isYArray(value$1)) throw new Error("Component props.components array must be YArray");
+			props.components = value$1.toArray().map((it) => yComponentToDynamicComponent(it));
+		} else if (extractContent && yComponent.doc && isYMap(value$1) && value$1.get("type") === "RichText" && typeof value$1.get("id") === "string") {
+			const id = value$1.get("id");
+			props[prop] = {
+				...value$1.toJSON(),
+				tiptap: yXmlFragmentToProsemirrorJSON(yComponent.doc.getXmlFragment(`RichText:${id}`))
+			};
+		} else if (value$1 instanceof Y.AbstractType) props[prop] = value$1.toJSON();
+		else props[prop] = value$1;
+		component.props = props;
+	} else if (isYArray(value)) component[key] = value.toArray();
+	else if (isYMap(value)) component[key] = value.toJSON();
+	else component[key] = value;
+	return component;
+};
+/**
+* This function converts a dynamic component to YComponent.
+*/
+const dynamicComponentToYComponent = (component) => {
+	return dynamicComponentToYMap(component);
+};
+/**
+* This function retrieves the properties of a YComponent.
+*/
+const getYComponentProps = (yComponent) => {
+	const props = yComponent.get("props");
+	if (!isYMap(props)) throw new Error(`Component hasn't "props" property. It must have to be defined as Y.Map (component: ${yComponent.get("id")})`);
+	return props;
+};
+/**
+* This function retrieves the array of components of a YComponent.
+*/
+const getYComponentComponentsArray = (yComponent) => {
+	const yComponents = getYComponentProps(yComponent).get("components");
+	if (!isYArray(yComponents)) throw new Error(`Component hasn't "props.components" property. It must be defined as Y.Array (component: ${yComponent.get("id")})`);
+	return yComponents;
+};
+/**
+* This function checks if a YComponent has a components array.
+* @example
+* // component
+* {
+*   id: "column",
+*   component: "column",
+*   props: {
+*     components: [...] <= has components array
+*   }
+* }
+*/
+const yComponentHasComponentsYArray = (yComponent) => {
+	return isYArray(getYComponentProps(yComponent).get("components"));
+};
+/**
+* This function retrieves the parent component of a YArray of YComponents.
+* @example
+* // parent component
+* {
+*   id: "column",
+*   component: "column",
+*   props: {
+*     components: [...] <= components array
+*   }
+* }
+*/
+const getYComponentsArrayParentComponent = (yArray) => {
+	return yArray.parent?.parent ?? null;
+};
+/**
+* This function finds a Y.Component in a Y.Array by its ID.
+*/
+const findYComponentInArray = (yArray, componentId) => {
+	const yComponent = yArray.toArray().find((it) => it.get("id") === componentId);
+	if (!yComponent) throw new Error(`Component with id ${componentId} not found in yArray`);
+	return yComponent;
+};
+
+//#endregion
+export { ID_PATH_KEY_PREFIX, IImageRenditionType, PATH_REGEXP, POSITION_ARRAY_KEY_PREFIX, arrayToYArray, copyDynamicComponent, createIdArrayKey, createPositionArrayKey, customAlphabet, defineDynamicComponent, defineDynamicComponents, dynamicComponentPropsToYComponentProps, dynamicComponentToYComponent, dynamicComponentToYMap, dynamicComponentsToYArray, entriesOf, existsInPath, extractIdFromArrayKey, extractPositionFromArrayKey, findInYArray, findIndexInYArray, findYComponentInArray, generateKeyBetween, getComponentPropertyPath, getComponentsSubtreeByPath, getComponentsSubtreeByRPath, getDataObjectKey, getFromPath, getFromYPath, getIndexByArrayKey, getRelativePoint, getSortedYArray, getYArrayIndexByArrayKey, getYArrayRefsByPosition, getYComponentComponentsArray, getYComponentProps, getYComponentsArrayParentComponent, insertInPath, insertYMapAfter, insertYMapBefore, insertYMapToEnd, isArrayKey, isBiblePassageComponent, isBibleQuoteComponent, isCallable, isChatMessageDelayComponent, isChatTextMessageComponent, isCheckboxComponent, isCheckboxGroupComponent, isCollectionComponent, isColumnComponent, isComputedValueComponent, isConfirmDeletionInputComponent, isContainerValue, isDateTimePickerComponent, isEmbedCodeComponent, isEmptyArray, isEmptyContainer, isEntitySelectComponent, isEqualPath, isFileUploaderComponent, isHeadingComponent, isIdArrayKey, isImageComponent, isImageUploaderComponent, isIndex, isLegacyContentComponent, isNullOrUndefined, isNumber, isNumberInputComponent, isObject, isPositionArrayKey, isPracticeComponent, isRadioGroupComponent, isRawImageUploaderComponent, isRawImagesUploaderComponent, isRepeatableCollectionComponent, isRichText, isRichTextComponent, isRichTextEditorComponent, isRowComponent, isRowSettingsComponent, isSamePath, isSelectComponent, isSimpleImageUploaderComponent, isSlugComponent, isStatementComponent, isString, isSwitchComponent, isTestComponent, isTextInputComponent, isTextareaComponent, isYArray, isYComponent, isYMap, joinPath, keysOf, makeDynamicComponentsWithPosition, moveInPath, moveInYPath, moveYMapAfter, moveYMapBefore, moveYMapToEnd, moveYMapToStart, objectToYMap, pullFromPath, pullFromYPath, pushInPath, pushInYPath, searchDynamicComponentInTree, setInPath, setInYPath, sortByPosition, sortDynamicComponents, uid, unsetPath, unsetYPath, urlAlphabet, yComponentHasComponentsYArray, yComponentToDynamicComponent };
+//# sourceMappingURL=index.js.map