Gutenberg / 23.4.0

Gutenberg v23.4.0

gutenberg / build / scripts / rich-text / index.js

index.js in Gutenberg 23.4.0, at build/scripts/rich-text/index.js

2,981 lines 99.1 KB

Raw Download Zip

1	"use strict";
2	var wp;
3	(wp \|\|= {}).richText = (() => {
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, all) => {
14	for (var name in all)
15	__defProp(target, name, { get: all[name], enumerable: true });
16	};
17	var __copyProps = (to, from, except, desc) => {
18	if (from && typeof from === "object" \|\| typeof from === "function") {
19	for (let key of __getOwnPropNames(from))
20	if (!__hasOwnProp.call(to, key) && key !== except)
21	__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, 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/data
36	var require_data = __commonJS({
37	"package-external:@wordpress/data"(exports, module) {
38	module.exports = window.wp.data;
39	}
40	});
41
42	// package-external:@wordpress/escape-html
43	var require_escape_html = __commonJS({
44	"package-external:@wordpress/escape-html"(exports, module) {
45	module.exports = window.wp.escapeHtml;
46	}
47	});
48
49	// package-external:@wordpress/a11y
50	var require_a11y = __commonJS({
51	"package-external:@wordpress/a11y"(exports, module) {
52	module.exports = window.wp.a11y;
53	}
54	});
55
56	// package-external:@wordpress/i18n
57	var require_i18n = __commonJS({
58	"package-external:@wordpress/i18n"(exports, module) {
59	module.exports = window.wp.i18n;
60	}
61	});
62
63	// package-external:@wordpress/private-apis
64	var require_private_apis = __commonJS({
65	"package-external:@wordpress/private-apis"(exports, module) {
66	module.exports = window.wp.privateApis;
67	}
68	});
69
70	// package-external:@wordpress/element
71	var require_element = __commonJS({
72	"package-external:@wordpress/element"(exports, module) {
73	module.exports = window.wp.element;
74	}
75	});
76
77	// package-external:@wordpress/compose
78	var require_compose = __commonJS({
79	"package-external:@wordpress/compose"(exports, module) {
80	module.exports = window.wp.compose;
81	}
82	});
83
84	// package-external:@wordpress/deprecated
85	var require_deprecated = __commonJS({
86	"package-external:@wordpress/deprecated"(exports, module) {
87	module.exports = window.wp.deprecated;
88	}
89	});
90
91	// package-external:@wordpress/keycodes
92	var require_keycodes = __commonJS({
93	"package-external:@wordpress/keycodes"(exports, module) {
94	module.exports = window.wp.keycodes;
95	}
96	});
97
98	// package-external:@wordpress/dom
99	var require_dom = __commonJS({
100	"package-external:@wordpress/dom"(exports, module) {
101	module.exports = window.wp.dom;
102	}
103	});
104
105	// packages/rich-text/build-module/index.mjs
106	var index_exports = {};
107	__export(index_exports, {
108	RichTextData: () => RichTextData,
109	__experimentalRichText: () => __experimentalRichText,
110	__unstableCreateElement: () => createElement,
111	__unstableToDom: () => toDom,
112	__unstableUseRichText: () => useDeprecatedRichText,
113	applyFormat: () => applyFormat,
114	concat: () => concat,
115	create: () => create,
116	getActiveFormat: () => getActiveFormat,
117	getActiveFormats: () => getActiveFormats,
118	getActiveObject: () => getActiveObject,
119	getTextContent: () => getTextContent,
120	insert: () => insert,
121	insertObject: () => insertObject,
122	isCollapsed: () => isCollapsed,
123	isEmpty: () => isEmpty,
124	join: () => join,
125	privateApis: () => privateApis,
126	registerFormatType: () => registerFormatType,
127	remove: () => remove2,
128	removeFormat: () => removeFormat,
129	replace: () => replace2,
130	slice: () => slice,
131	split: () => split,
132	store: () => store,
133	toHTMLString: () => toHTMLString,
134	toggleFormat: () => toggleFormat,
135	unregisterFormatType: () => unregisterFormatType,
136	useAnchor: () => useAnchor,
137	useAnchorRef: () => useAnchorRef
138	});
139
140	// packages/rich-text/build-module/store/index.mjs
141	var import_data3 = __toESM(require_data(), 1);
142
143	// packages/rich-text/build-module/store/reducer.mjs
144	var import_data = __toESM(require_data(), 1);
145	function formatTypes(state = {}, action) {
146	switch (action.type) {
147	case "ADD_FORMAT_TYPES":
148	return {
149	...state,
150	// Key format types by their name.
151	...action.formatTypes.reduce(
152	(newFormatTypes, type) => ({
153	...newFormatTypes,
154	[type.name]: type
155	}),
156	{}
157	)
158	};
159	case "REMOVE_FORMAT_TYPES":
160	return Object.fromEntries(
161	Object.entries(state).filter(
162	([key]) => !action.names.includes(key)
163	)
164	);
165	}
166	return state;
167	}
168	var reducer_default = (0, import_data.combineReducers)({ formatTypes });
169
170	// packages/rich-text/build-module/store/selectors.mjs
171	var selectors_exports = {};
172	__export(selectors_exports, {
173	getFormatType: () => getFormatType,
174	getFormatTypeForBareElement: () => getFormatTypeForBareElement,
175	getFormatTypeForClassName: () => getFormatTypeForClassName,
176	getFormatTypes: () => getFormatTypes
177	});
178	var import_data2 = __toESM(require_data(), 1);
179	var getFormatTypes = (0, import_data2.createSelector)(
180	(state) => Object.values(state.formatTypes),
181	(state) => [state.formatTypes]
182	);
183	function getFormatType(state, name) {
184	return state.formatTypes[name];
185	}
186	function getFormatTypeForBareElement(state, bareElementTagName) {
187	const formatTypes2 = getFormatTypes(state);
188	return formatTypes2.find(({ className, tagName }) => {
189	return className === null && bareElementTagName === tagName;
190	}) \|\| formatTypes2.find(({ className, tagName }) => {
191	return className === null && "*" === tagName;
192	});
193	}
194	function getFormatTypeForClassName(state, elementClassName) {
195	return getFormatTypes(state).find(({ className }) => {
196	if (className === null) {
197	return false;
198	}
199	return ` ${elementClassName} `.indexOf(` ${className} `) >= 0;
200	});
201	}
202
203	// packages/rich-text/build-module/store/actions.mjs
204	var actions_exports = {};
205	__export(actions_exports, {
206	addFormatTypes: () => addFormatTypes,
207	removeFormatTypes: () => removeFormatTypes
208	});
209	function addFormatTypes(formatTypes2) {
210	return {
211	type: "ADD_FORMAT_TYPES",
212	formatTypes: Array.isArray(formatTypes2) ? formatTypes2 : [formatTypes2]
213	};
214	}
215	function removeFormatTypes(names) {
216	return {
217	type: "REMOVE_FORMAT_TYPES",
218	names: Array.isArray(names) ? names : [names]
219	};
220	}
221
222	// packages/rich-text/build-module/store/index.mjs
223	var STORE_NAME = "core/rich-text";
224	var store = (0, import_data3.createReduxStore)(STORE_NAME, {
225	reducer: reducer_default,
226	selectors: selectors_exports,
227	actions: actions_exports
228	});
229	(0, import_data3.register)(store);
230
231	// packages/rich-text/build-module/is-format-equal.mjs
232	function isFormatEqual(format1, format2) {
233	if (format1 === format2) {
234	return true;
235	}
236	if (!format1 \|\| !format2) {
237	return false;
238	}
239	if (format1.type !== format2.type) {
240	return false;
241	}
242	const attributes1 = format1.attributes;
243	const attributes2 = format2.attributes;
244	if (attributes1 === attributes2) {
245	return true;
246	}
247	if (!attributes1 \|\| !attributes2) {
248	return false;
249	}
250	const keys1 = Object.keys(attributes1);
251	const keys2 = Object.keys(attributes2);
252	if (keys1.length !== keys2.length) {
253	return false;
254	}
255	const length = keys1.length;
256	for (let i2 = 0; i2 < length; i2++) {
257	const name = keys1[i2];
258	if (attributes1[name] !== attributes2[name]) {
259	return false;
260	}
261	}
262	return true;
263	}
264
265	// packages/rich-text/build-module/normalise-formats.mjs
266	function normaliseFormats(value) {
267	const newFormats = value.formats.slice();
268	newFormats.forEach((formatsAtIndex, index) => {
269	const formatsAtPreviousIndex = newFormats[index - 1];
270	if (formatsAtPreviousIndex) {
271	const newFormatsAtIndex = formatsAtIndex.slice();
272	newFormatsAtIndex.forEach((format, formatIndex) => {
273	const previousFormat = formatsAtPreviousIndex[formatIndex];
274	if (isFormatEqual(format, previousFormat)) {
275	newFormatsAtIndex[formatIndex] = previousFormat;
276	}
277	});
278	newFormats[index] = newFormatsAtIndex;
279	}
280	});
281	return {
282	...value,
283	formats: newFormats
284	};
285	}
286
287	// packages/rich-text/build-module/apply-format.mjs
288	function replace(array, index, value) {
289	array = array.slice();
290	array[index] = value;
291	return array;
292	}
293	function applyFormat(value, format, startIndex = value.start, endIndex = value.end) {
294	const { formats, activeFormats } = value;
295	const newFormats = formats.slice();
296	if (startIndex === endIndex) {
297	const startFormat = newFormats[startIndex]?.find(
298	({ type }) => type === format.type
299	);
300	if (startFormat) {
301	const index = newFormats[startIndex].indexOf(startFormat);
302	while (newFormats[startIndex] && newFormats[startIndex][index] === startFormat) {
303	newFormats[startIndex] = replace(
304	newFormats[startIndex],
305	index,
306	format
307	);
308	startIndex--;
309	}
310	endIndex++;
311	while (newFormats[endIndex] && newFormats[endIndex][index] === startFormat) {
312	newFormats[endIndex] = replace(
313	newFormats[endIndex],
314	index,
315	format
316	);
317	endIndex++;
318	}
319	}
320	} else {
321	let position = Infinity;
322	for (let index = startIndex; index < endIndex; index++) {
323	if (newFormats[index]) {
324	newFormats[index] = newFormats[index].filter(
325	({ type }) => type !== format.type
326	);
327	const length = newFormats[index].length;
328	if (length < position) {
329	position = length;
330	}
331	} else {
332	newFormats[index] = [];
333	position = 0;
334	}
335	}
336	for (let index = startIndex; index < endIndex; index++) {
337	newFormats[index].splice(position, 0, format);
338	}
339	}
340	return normaliseFormats({
341	...value,
342	formats: newFormats,
343	// Always revise active formats. This serves as a placeholder for new
344	// inputs with the format so new input appears with the format applied,
345	// and ensures a format of the same type uses the latest values.
346	activeFormats: [
347	...activeFormats?.filter(
348	({ type }) => type !== format.type
349	) \|\| [],
350	format
351	]
352	});
353	}
354
355	// packages/rich-text/build-module/create.mjs
356	var import_data5 = __toESM(require_data(), 1);
357
358	// packages/rich-text/build-module/create-element.mjs
359	function createElement({ implementation }, html) {
360	if (!createElement.body) {
361	createElement.body = implementation.createHTMLDocument("").body;
362	}
363	createElement.body.innerHTML = html;
364	return createElement.body;
365	}
366
367	// packages/rich-text/build-module/special-characters.mjs
368	var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
369	var ZWNBSP = "\uFEFF";
370
371	// packages/rich-text/build-module/to-html-string.mjs
372	var import_escape_html = __toESM(require_escape_html(), 1);
373
374	// packages/rich-text/build-module/get-active-formats.mjs
375	function getActiveFormats(value, EMPTY_ACTIVE_FORMATS3 = []) {
376	const { formats, start, end, activeFormats } = value;
377	if (start === void 0) {
378	return EMPTY_ACTIVE_FORMATS3;
379	}
380	if (start === end) {
381	if (activeFormats) {
382	return activeFormats;
383	}
384	const formatsBefore = formats[start - 1] \|\| EMPTY_ACTIVE_FORMATS3;
385	const formatsAfter = formats[start] \|\| EMPTY_ACTIVE_FORMATS3;
386	if (formatsBefore.length < formatsAfter.length) {
387	return formatsBefore;
388	}
389	return formatsAfter;
390	}
391	if (!formats[start]) {
392	return EMPTY_ACTIVE_FORMATS3;
393	}
394	const selectedFormats = formats.slice(start, end);
395	const _activeFormats = [...selectedFormats[0]];
396	let i2 = selectedFormats.length;
397	while (i2--) {
398	const formatsAtIndex = selectedFormats[i2];
399	if (!formatsAtIndex) {
400	return EMPTY_ACTIVE_FORMATS3;
401	}
402	let ii = _activeFormats.length;
403	while (ii--) {
404	const format = _activeFormats[ii];
405	if (!formatsAtIndex.find(
406	(_format) => isFormatEqual(format, _format)
407	)) {
408	_activeFormats.splice(ii, 1);
409	}
410	}
411	if (_activeFormats.length === 0) {
412	return EMPTY_ACTIVE_FORMATS3;
413	}
414	}
415	return _activeFormats \|\| EMPTY_ACTIVE_FORMATS3;
416	}
417
418	// packages/rich-text/build-module/get-format-type.mjs
419	var import_data4 = __toESM(require_data(), 1);
420	function getFormatType2(name) {
421	return (0, import_data4.select)(store).getFormatType(name);
422	}
423
424	// packages/rich-text/build-module/to-tree.mjs
425	function restoreOnAttributes(attributes, isEditableTree) {
426	if (isEditableTree) {
427	return attributes;
428	}
429	const newAttributes = {};
430	for (const key in attributes) {
431	let newKey = key;
432	if (key.startsWith("data-disable-rich-text-")) {
433	newKey = key.slice("data-disable-rich-text-".length);
434	}
435	newAttributes[newKey] = attributes[key];
436	}
437	return newAttributes;
438	}
439	function fromFormat({
440	type,
441	tagName,
442	attributes,
443	unregisteredAttributes,
444	object,
445	boundaryClass,
446	isEditableTree
447	}) {
448	const formatType = getFormatType2(type);
449	let elementAttributes = {};
450	if (boundaryClass && isEditableTree) {
451	elementAttributes["data-rich-text-format-boundary"] = "true";
452	}
453	if (!formatType) {
454	if (attributes) {
455	elementAttributes = { ...attributes, ...elementAttributes };
456	}
457	return {
458	type,
459	attributes: restoreOnAttributes(
460	elementAttributes,
461	isEditableTree
462	),
463	object
464	};
465	}
466	elementAttributes = { ...unregisteredAttributes, ...elementAttributes };
467	for (const name in attributes) {
468	const key = formatType.attributes ? formatType.attributes[name] : false;
469	if (key) {
470	elementAttributes[key] = attributes[name];
471	} else {
472	elementAttributes[name] = attributes[name];
473	}
474	}
475	if (formatType.className) {
476	if (elementAttributes.class) {
477	elementAttributes.class = `${formatType.className} ${elementAttributes.class}`;
478	} else {
479	elementAttributes.class = formatType.className;
480	}
481	}
482	return {
483	type: tagName \|\| formatType.tagName,
484	object: formatType.object,
485	attributes: restoreOnAttributes(elementAttributes, isEditableTree)
486	};
487	}
488	function isEqualUntil(a2, b2, index) {
489	do {
490	if (a2[index] !== b2[index]) {
491	return false;
492	}
493	} while (index--);
494	return true;
495	}
496	function toTree({
497	value,
498	preserveWhiteSpace,
499	createEmpty: createEmpty2,
500	append: append3,
501	getLastChild: getLastChild3,
502	getParent: getParent3,
503	isText: isText3,
504	getText: getText3,
505	remove: remove4,
506	appendText: appendText3,
507	onStartIndex,
508	onEndIndex,
509	isEditableTree,
510	placeholder
511	}) {
512	const { formats, replacements, text, start, end } = value;
513	const formatsLength = formats.length + 1;
514	const tree = createEmpty2();
515	const activeFormats = getActiveFormats(value);
516	const deepestActiveFormat = activeFormats[activeFormats.length - 1];
517	let lastCharacterFormats;
518	let lastCharacter;
519	append3(tree, "");
520	for (let i2 = 0; i2 < formatsLength; i2++) {
521	const character = text.charAt(i2);
522	const shouldInsertPadding = isEditableTree && // Pad the line if the line is empty.
523	(!lastCharacter \|\| // Pad the line if the previous character is a line break, otherwise
524	// the line break won't be visible.
525	lastCharacter === "\n");
526	const characterFormats = formats[i2];
527	let pointer = getLastChild3(tree);
528	if (characterFormats) {
529	characterFormats.forEach((format, formatIndex) => {
530	if (pointer && lastCharacterFormats && // Reuse the last element if all formats remain the same.
531	isEqualUntil(
532	characterFormats,
533	lastCharacterFormats,
534	formatIndex
535	)) {
536	pointer = getLastChild3(pointer);
537	return;
538	}
539	const { type, tagName, attributes, unregisteredAttributes } = format;
540	const boundaryClass = isEditableTree && format === deepestActiveFormat;
541	const parent = getParent3(pointer);
542	const newNode = append3(
543	parent,
544	fromFormat({
545	type,
546	tagName,
547	attributes,
548	unregisteredAttributes,
549	boundaryClass,
550	isEditableTree
551	})
552	);
553	if (isText3(pointer) && getText3(pointer).length === 0) {
554	remove4(pointer);
555	}
556	pointer = append3(newNode, "");
557	});
558	}
559	if (i2 === 0) {
560	if (onStartIndex && start === 0) {
561	onStartIndex(tree, pointer);
562	}
563	if (onEndIndex && end === 0) {
564	onEndIndex(tree, pointer);
565	}
566	}
567	if (character === OBJECT_REPLACEMENT_CHARACTER) {
568	const replacement = replacements[i2];
569	if (!replacement) {
570	continue;
571	}
572	const { type, attributes, innerHTML } = replacement;
573	const formatType = getFormatType2(type);
574	if (isEditableTree && type === "#comment") {
575	pointer = append3(getParent3(pointer), {
576	type: "span",
577	attributes: {
578	contenteditable: "false",
579	"data-rich-text-comment": attributes["data-rich-text-comment"]
580	}
581	});
582	append3(
583	append3(pointer, { type: "span" }),
584	attributes["data-rich-text-comment"].trim()
585	);
586	} else if (!isEditableTree && type === "script") {
587	pointer = append3(
588	getParent3(pointer),
589	fromFormat({
590	type: "script",
591	isEditableTree
592	})
593	);
594	append3(pointer, {
595	html: decodeURIComponent(
596	attributes["data-rich-text-script"]
597	)
598	});
599	} else if (formatType?.contentEditable === false) {
600	if (innerHTML \|\| isEditableTree) {
601	pointer = getParent3(pointer);
602	if (isEditableTree) {
603	const attrs = {
604	contenteditable: "false",
605	"data-rich-text-bogus": true
606	};
607	if (start === i2 && end === i2 + 1) {
608	attrs["data-rich-text-format-boundary"] = true;
609	}
610	pointer = append3(pointer, {
611	type: "span",
612	attributes: attrs
613	});
614	if (isEditableTree && i2 + 1 === text.length) {
615	append3(getParent3(pointer), ZWNBSP);
616	}
617	}
618	pointer = append3(
619	pointer,
620	fromFormat({
621	...replacement,
622	isEditableTree
623	})
624	);
625	if (innerHTML) {
626	append3(pointer, {
627	html: innerHTML
628	});
629	}
630	}
631	} else {
632	pointer = append3(
633	getParent3(pointer),
634	fromFormat({
635	...replacement,
636	object: true,
637	isEditableTree
638	})
639	);
640	}
641	pointer = append3(getParent3(pointer), "");
642	} else if (!preserveWhiteSpace && character === "\n") {
643	pointer = append3(getParent3(pointer), {
644	type: "br",
645	attributes: isEditableTree ? {
646	"data-rich-text-line-break": "true"
647	} : void 0,
648	object: true
649	});
650	pointer = append3(getParent3(pointer), "");
651	} else if (!isText3(pointer)) {
652	pointer = append3(getParent3(pointer), character);
653	} else {
654	appendText3(pointer, character);
655	}
656	if (onStartIndex && start === i2 + 1) {
657	onStartIndex(tree, pointer);
658	}
659	if (onEndIndex && end === i2 + 1) {
660	onEndIndex(tree, pointer);
661	}
662	if (shouldInsertPadding && i2 === text.length) {
663	append3(getParent3(pointer), ZWNBSP);
664	if (placeholder && text.length === 0) {
665	append3(getParent3(pointer), {
666	type: "span",
667	attributes: {
668	"data-rich-text-placeholder": placeholder,
669	// Necessary to prevent the placeholder from catching
670	// selection and being editable.
671	style: "pointer-events:none;user-select:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;"
672	}
673	});
674	}
675	}
676	lastCharacterFormats = characterFormats;
677	lastCharacter = character;
678	}
679	return tree;
680	}
681
682	// packages/rich-text/build-module/to-html-string.mjs
683	function toHTMLString({ value, preserveWhiteSpace }) {
684	const tree = toTree({
685	value,
686	preserveWhiteSpace,
687	createEmpty,
688	append,
689	getLastChild,
690	getParent,
691	isText,
692	getText,
693	remove,
694	appendText
695	});
696	return createChildrenHTML(tree.children);
697	}
698	function createEmpty() {
699	return {};
700	}
701	function getLastChild({ children }) {
702	return children && children[children.length - 1];
703	}
704	function append(parent, object) {
705	if (typeof object === "string") {
706	object = { text: object };
707	}
708	object.parent = parent;
709	parent.children = parent.children \|\| [];
710	parent.children.push(object);
711	return object;
712	}
713	function appendText(object, text) {
714	object.text += text;
715	}
716	function getParent({ parent }) {
717	return parent;
718	}
719	function isText({ text }) {
720	return typeof text === "string";
721	}
722	function getText({ text }) {
723	return text;
724	}
725	function remove(object) {
726	const index = object.parent.children.indexOf(object);
727	if (index !== -1) {
728	object.parent.children.splice(index, 1);
729	}
730	return object;
731	}
732	function createElementHTML({ type, attributes, object, children }) {
733	if (type === "#comment") {
734	return `<!--${attributes["data-rich-text-comment"]}-->`;
735	}
736	let attributeString = "";
737	for (const key in attributes) {
738	if (!(0, import_escape_html.isValidAttributeName)(key)) {
739	continue;
740	}
741	attributeString += ` ${key}="${(0, import_escape_html.escapeAttribute)(
742	attributes[key]
743	)}"`;
744	}
745	if (object) {
746	return `<${type}${attributeString}>`;
747	}
748	return `<${type}${attributeString}>${createChildrenHTML(
749	children
750	)}</${type}>`;
751	}
752	function createChildrenHTML(children = []) {
753	return children.map((child) => {
754	if (child.html !== void 0) {
755	return child.html;
756	}
757	return child.text === void 0 ? createElementHTML(child) : (0, import_escape_html.escapeEditableHTML)(child.text);
758	}).join("");
759	}
760
761	// packages/rich-text/build-module/get-text-content.mjs
762	function getTextContent({ text }) {
763	return text.replace(OBJECT_REPLACEMENT_CHARACTER, "");
764	}
765
766	// packages/rich-text/build-module/create.mjs
767	function createEmptyValue() {
768	return {
769	formats: [],
770	replacements: [],
771	text: ""
772	};
773	}
774	function toFormat({ tagName, attributes }) {
775	let formatType;
776	if (attributes && attributes.class) {
777	formatType = (0, import_data5.select)(store).getFormatTypeForClassName(
778	attributes.class
779	);
780	if (formatType) {
781	attributes.class = ` ${attributes.class} `.replace(` ${formatType.className} `, " ").trim();
782	if (!attributes.class) {
783	delete attributes.class;
784	}
785	}
786	}
787	if (!formatType) {
788	formatType = (0, import_data5.select)(store).getFormatTypeForBareElement(tagName);
789	}
790	if (!formatType) {
791	return attributes ? { type: tagName, attributes } : { type: tagName };
792	}
793	if (formatType.__experimentalCreatePrepareEditableTree && !formatType.__experimentalCreateOnChangeEditableValue) {
794	return null;
795	}
796	if (!attributes) {
797	return { formatType, type: formatType.name, tagName };
798	}
799	const registeredAttributes = {};
800	const unregisteredAttributes = {};
801	const _attributes = { ...attributes };
802	for (const key in formatType.attributes) {
803	const name = formatType.attributes[key];
804	registeredAttributes[key] = _attributes[name];
805	delete _attributes[name];
806	if (typeof registeredAttributes[key] === "undefined") {
807	delete registeredAttributes[key];
808	}
809	}
810	for (const name in _attributes) {
811	unregisteredAttributes[name] = attributes[name];
812	}
813	if (formatType.contentEditable === false) {
814	delete unregisteredAttributes.contenteditable;
815	}
816	return {
817	formatType,
818	type: formatType.name,
819	tagName,
820	attributes: registeredAttributes,
821	unregisteredAttributes
822	};
823	}
824	var RichTextData = class _RichTextData {
825	#value;
826	static empty() {
827	return new _RichTextData();
828	}
829	static fromPlainText(text) {
830	return new _RichTextData(create({ text }));
831	}
832	static fromHTMLString(html) {
833	return new _RichTextData(create({ html }));
834	}
835	/**
836	* Create a RichTextData instance from an HTML element.
837	*
838	* @param {HTMLElement} htmlElement The HTML element to create the instance from.
839	* @param {{preserveWhiteSpace?: boolean}} options Options.
840	* @return {RichTextData} The RichTextData instance.
841	*/
842	static fromHTMLElement(htmlElement, options = {}) {
843	const { preserveWhiteSpace = false } = options;
844	const element = preserveWhiteSpace ? htmlElement : collapseWhiteSpace(htmlElement);
845	const richTextData = new _RichTextData(create({ element }));
846	Object.defineProperty(richTextData, "originalHTML", {
847	value: htmlElement.innerHTML
848	});
849	return richTextData;
850	}
851	constructor(init = createEmptyValue()) {
852	this.#value = init;
853	}
854	toPlainText() {
855	return getTextContent(this.#value);
856	}
857	// We could expose `toHTMLElement` at some point as well, but we'd only use
858	// it internally.
859	/**
860	* Convert the rich text value to an HTML string.
861	*
862	* @param {{preserveWhiteSpace?: boolean}} options Options.
863	* @return {string} The HTML string.
864	*/
865	toHTMLString({ preserveWhiteSpace } = {}) {
866	return this.originalHTML \|\| toHTMLString({ value: this.#value, preserveWhiteSpace });
867	}
868	valueOf() {
869	return this.toHTMLString();
870	}
871	toString() {
872	return this.toHTMLString();
873	}
874	toJSON() {
875	return this.toHTMLString();
876	}
877	get length() {
878	return this.text.length;
879	}
880	get formats() {
881	return this.#value.formats;
882	}
883	get replacements() {
884	return this.#value.replacements;
885	}
886	get text() {
887	return this.#value.text;
888	}
889	};
890	for (const name of Object.getOwnPropertyNames(String.prototype)) {
891	if (RichTextData.prototype.hasOwnProperty(name)) {
892	continue;
893	}
894	Object.defineProperty(RichTextData.prototype, name, {
895	value(...args) {
896	return this.toHTMLString()[name](...args);
897	}
898	});
899	}
900	function create({
901	element,
902	text,
903	html,
904	range,
905	__unstableIsEditableTree: isEditableTree
906	} = {}) {
907	if (html instanceof RichTextData) {
908	return {
909	text: html.text,
910	formats: html.formats,
911	replacements: html.replacements
912	};
913	}
914	if (typeof text === "string" && text.length > 0) {
915	return {
916	formats: Array(text.length),
917	replacements: Array(text.length),
918	text
919	};
920	}
921	if (typeof html === "string" && html.length > 0) {
922	element = createElement(document, html);
923	}
924	if (typeof element !== "object") {
925	return createEmptyValue();
926	}
927	return createFromElement({
928	element,
929	range,
930	isEditableTree
931	});
932	}
933	function accumulateSelection(accumulator, node, range, value) {
934	if (!range) {
935	return;
936	}
937	const { parentNode } = node;
938	const { startContainer, startOffset, endContainer, endOffset } = range;
939	const currentLength = accumulator.text.length;
940	if (value.start !== void 0) {
941	accumulator.start = currentLength + value.start;
942	} else if (node === startContainer && node.nodeType === node.TEXT_NODE) {
943	accumulator.start = currentLength + startOffset;
944	} else if (parentNode === startContainer && node === startContainer.childNodes[startOffset]) {
945	accumulator.start = currentLength;
946	} else if (parentNode === startContainer && node === startContainer.childNodes[startOffset - 1]) {
947	accumulator.start = currentLength + value.text.length;
948	} else if (node === startContainer) {
949	accumulator.start = currentLength;
950	}
951	if (value.end !== void 0) {
952	accumulator.end = currentLength + value.end;
953	} else if (node === endContainer && node.nodeType === node.TEXT_NODE) {
954	accumulator.end = currentLength + endOffset;
955	} else if (parentNode === endContainer && node === endContainer.childNodes[endOffset - 1]) {
956	accumulator.end = currentLength + value.text.length;
957	} else if (parentNode === endContainer && node === endContainer.childNodes[endOffset]) {
958	accumulator.end = currentLength;
959	} else if (node === endContainer) {
960	accumulator.end = currentLength + endOffset;
961	}
962	}
963	function filterRange(node, range, filter) {
964	if (!range) {
965	return;
966	}
967	const { startContainer, endContainer } = range;
968	let { startOffset, endOffset } = range;
969	if (node === startContainer) {
970	startOffset = filter(node.nodeValue.slice(0, startOffset)).length;
971	}
972	if (node === endContainer) {
973	endOffset = filter(node.nodeValue.slice(0, endOffset)).length;
974	}
975	return { startContainer, startOffset, endContainer, endOffset };
976	}
977	function collapseWhiteSpace(element, isRoot = true, hasPrecedingSpace = false, hasTrailingSpace = false) {
978	const clone = element.cloneNode(true);
979	clone.normalize();
980	Array.from(clone.childNodes).forEach((node, i2, nodes) => {
981	if (node.nodeType === node.TEXT_NODE) {
982	let newNodeValue = node.nodeValue;
983	if (/[\n\t\r\f]/.test(newNodeValue)) {
984	newNodeValue = newNodeValue.replace(/[\n\t\r\f]+/g, " ");
985	}
986	if (newNodeValue.indexOf(" ") !== -1) {
987	newNodeValue = newNodeValue.replace(/ {2,}/g, " ");
988	}
989	if (i2 === 0 && newNodeValue.startsWith(" ") && (isRoot \|\| hasPrecedingSpace)) {
990	newNodeValue = newNodeValue.slice(1);
991	}
992	if (i2 === nodes.length - 1 && newNodeValue.endsWith(" ") && (isRoot \|\| hasTrailingSpace)) {
993	newNodeValue = newNodeValue.slice(0, -1);
994	}
995	node.nodeValue = newNodeValue;
996	} else if (node.nodeType === node.ELEMENT_NODE) {
997	const { previousSibling, nextSibling } = node;
998	const prevHasSpace = previousSibling?.textContent.endsWith(" ");
999	const nextHasSpace = nextSibling?.textContent.startsWith(" ");
1000	node.replaceWith(
1001	collapseWhiteSpace(
1002	node,
1003	false,
1004	previousSibling ? prevHasSpace : isRoot \|\| hasPrecedingSpace,
1005	nextSibling ? nextHasSpace : isRoot \|\| hasTrailingSpace
1006	)
1007	);
1008	}
1009	});
1010	return clone;
1011	}
1012	var CARRIAGE_RETURN = "\r";
1013	function removeReservedCharacters(string) {
1014	return string.replace(
1015	new RegExp(
1016	`[${ZWNBSP}${OBJECT_REPLACEMENT_CHARACTER}${CARRIAGE_RETURN}]`,
1017	"gu"
1018	),
1019	""
1020	);
1021	}
1022	function createFromElement({ element, range, isEditableTree }) {
1023	const accumulator = createEmptyValue();
1024	if (!element) {
1025	return accumulator;
1026	}
1027	if (!element.hasChildNodes()) {
1028	accumulateSelection(accumulator, element, range, createEmptyValue());
1029	return accumulator;
1030	}
1031	const length = element.childNodes.length;
1032	for (let index = 0; index < length; index++) {
1033	const node = element.childNodes[index];
1034	const tagName = node.nodeName.toLowerCase();
1035	if (node.nodeType === node.TEXT_NODE) {
1036	const text = removeReservedCharacters(node.nodeValue);
1037	range = filterRange(node, range, removeReservedCharacters);
1038	accumulateSelection(accumulator, node, range, { text });
1039	accumulator.formats.length += text.length;
1040	accumulator.replacements.length += text.length;
1041	accumulator.text += text;
1042	continue;
1043	}
1044	if (node.nodeType === node.COMMENT_NODE \|\| node.nodeType === node.ELEMENT_NODE && node.tagName === "SPAN" && node.hasAttribute("data-rich-text-comment")) {
1045	const value2 = {
1046	formats: [,],
1047	replacements: [
1048	{
1049	type: "#comment",
1050	attributes: {
1051	"data-rich-text-comment": node.nodeType === node.COMMENT_NODE ? node.nodeValue : node.getAttribute(
1052	"data-rich-text-comment"
1053	)
1054	}
1055	}
1056	],
1057	text: OBJECT_REPLACEMENT_CHARACTER
1058	};
1059	accumulateSelection(accumulator, node, range, value2);
1060	mergePair(accumulator, value2);
1061	continue;
1062	}
1063	if (node.nodeType !== node.ELEMENT_NODE) {
1064	continue;
1065	}
1066	if (isEditableTree && // Ignore any line breaks that are not inserted by us.
1067	tagName === "br" && !node.getAttribute("data-rich-text-line-break")) {
1068	accumulateSelection(accumulator, node, range, createEmptyValue());
1069	continue;
1070	}
1071	if (tagName === "script") {
1072	const value2 = {
1073	formats: [,],
1074	replacements: [
1075	{
1076	type: tagName,
1077	attributes: {
1078	"data-rich-text-script": node.getAttribute("data-rich-text-script") \|\| encodeURIComponent(node.innerHTML)
1079	}
1080	}
1081	],
1082	text: OBJECT_REPLACEMENT_CHARACTER
1083	};
1084	accumulateSelection(accumulator, node, range, value2);
1085	mergePair(accumulator, value2);
1086	continue;
1087	}
1088	if (tagName === "br") {
1089	accumulateSelection(accumulator, node, range, createEmptyValue());
1090	mergePair(accumulator, create({ text: "\n" }));
1091	continue;
1092	}
1093	const format = toFormat({
1094	tagName,
1095	attributes: getAttributes({ element: node })
1096	});
1097	if (format?.formatType?.contentEditable === false) {
1098	delete format.formatType;
1099	accumulateSelection(accumulator, node, range, createEmptyValue());
1100	mergePair(accumulator, {
1101	formats: [,],
1102	replacements: [
1103	{
1104	...format,
1105	innerHTML: node.innerHTML
1106	}
1107	],
1108	text: OBJECT_REPLACEMENT_CHARACTER
1109	});
1110	continue;
1111	}
1112	if (format) {
1113	delete format.formatType;
1114	}
1115	const value = createFromElement({
1116	element: node,
1117	range,
1118	isEditableTree
1119	});
1120	accumulateSelection(accumulator, node, range, value);
1121	if (!format \|\| node.getAttribute("data-rich-text-placeholder") \|\| node.getAttribute("data-rich-text-bogus")) {
1122	mergePair(accumulator, value);
1123	} else if (value.text.length === 0) {
1124	if (format.attributes) {
1125	mergePair(accumulator, {
1126	formats: [,],
1127	replacements: [format],
1128	text: OBJECT_REPLACEMENT_CHARACTER
1129	});
1130	}
1131	} else {
1132	let mergeFormats2 = function(formats) {
1133	if (mergeFormats2.formats === formats) {
1134	return mergeFormats2.newFormats;
1135	}
1136	const newFormats = formats ? [format, ...formats] : [format];
1137	mergeFormats2.formats = formats;
1138	mergeFormats2.newFormats = newFormats;
1139	return newFormats;
1140	};
1141	var mergeFormats = mergeFormats2;
1142	mergeFormats2.newFormats = [format];
1143	mergePair(accumulator, {
1144	...value,
1145	formats: Array.from(value.formats, mergeFormats2)
1146	});
1147	}
1148	}
1149	return accumulator;
1150	}
1151	function getAttributes({ element }) {
1152	if (!element.hasAttributes()) {
1153	return;
1154	}
1155	const length = element.attributes.length;
1156	let accumulator;
1157	for (let i2 = 0; i2 < length; i2++) {
1158	const { name, value } = element.attributes[i2];
1159	if (name.indexOf("data-rich-text-") === 0) {
1160	continue;
1161	}
1162	const safeName = /^on/i.test(name) ? "data-disable-rich-text-" + name : name;
1163	accumulator = accumulator \|\| {};
1164	accumulator[safeName] = value;
1165	}
1166	return accumulator;
1167	}
1168
1169	// packages/rich-text/build-module/concat.mjs
1170	function mergePair(a2, b2) {
1171	a2.formats = a2.formats.concat(b2.formats);
1172	a2.replacements = a2.replacements.concat(b2.replacements);
1173	a2.text += b2.text;
1174	return a2;
1175	}
1176	function concat(...values) {
1177	return normaliseFormats(values.reduce(mergePair, create()));
1178	}
1179
1180	// packages/rich-text/build-module/get-active-format.mjs
1181	function getActiveFormat(value, formatType) {
1182	return getActiveFormats(value).find(
1183	({ type }) => type === formatType
1184	);
1185	}
1186
1187	// packages/rich-text/build-module/get-active-object.mjs
1188	function getActiveObject({ start, end, replacements, text }) {
1189	if (start + 1 !== end \|\| text[start] !== OBJECT_REPLACEMENT_CHARACTER) {
1190	return;
1191	}
1192	return replacements[start];
1193	}
1194
1195	// packages/rich-text/build-module/is-collapsed.mjs
1196	function isCollapsed({
1197	start,
1198	end
1199	}) {
1200	if (start === void 0 \|\| end === void 0) {
1201	return;
1202	}
1203	return start === end;
1204	}
1205
1206	// packages/rich-text/build-module/is-empty.mjs
1207	function isEmpty({ text }) {
1208	return text.length === 0;
1209	}
1210
1211	// packages/rich-text/build-module/join.mjs
1212	function join(values, separator = "") {
1213	if (typeof separator === "string") {
1214	separator = create({ text: separator });
1215	}
1216	return normaliseFormats(
1217	values.reduce((accumulator, { formats, replacements, text }) => ({
1218	formats: accumulator.formats.concat(separator.formats, formats),
1219	replacements: accumulator.replacements.concat(
1220	separator.replacements,
1221	replacements
1222	),
1223	text: accumulator.text + separator.text + text
1224	}))
1225	);
1226	}
1227
1228	// packages/rich-text/build-module/register-format-type.mjs
1229	var import_data6 = __toESM(require_data(), 1);
1230	function registerFormatType(name, settings) {
1231	settings = {
1232	name,
1233	...settings
1234	};
1235	if (typeof settings.name !== "string") {
1236	window.console.error("Format names must be strings.");
1237	return;
1238	}
1239	if (!/^[a-z][a-z0-9-]\/[a-z][a-z0-9-]$/.test(settings.name)) {
1240	window.console.error(
1241	"Format names must contain a namespace prefix, include only lowercase alphanumeric characters or dashes, and start with a letter. Example: my-plugin/my-custom-format"
1242	);
1243	return;
1244	}
1245	if ((0, import_data6.select)(store).getFormatType(settings.name)) {
1246	window.console.error(
1247	'Format "' + settings.name + '" is already registered.'
1248	);
1249	return;
1250	}
1251	if (typeof settings.tagName !== "string" \|\| settings.tagName === "") {
1252	window.console.error("Format tag names must be a string.");
1253	return;
1254	}
1255	if ((typeof settings.className !== "string" \|\| settings.className === "") && settings.className !== null) {
1256	window.console.error(
1257	"Format class names must be a string, or null to handle bare elements."
1258	);
1259	return;
1260	}
1261	if (!/^[_a-zA-Z]+[a-zA-Z0-9_-]*$/.test(settings.className)) {
1262	window.console.error(
1263	"A class name must begin with a letter, followed by any number of hyphens, underscores, letters, or numbers."
1264	);
1265	return;
1266	}
1267	if (settings.className === null) {
1268	const formatTypeForBareElement = (0, import_data6.select)(
1269	store
1270	).getFormatTypeForBareElement(settings.tagName);
1271	if (formatTypeForBareElement && formatTypeForBareElement.name !== "core/unknown") {
1272	window.console.error(
1273	`Format "${formatTypeForBareElement.name}" is already registered to handle bare tag name "${settings.tagName}".`
1274	);
1275	return;
1276	}
1277	} else {
1278	const formatTypeForClassName = (0, import_data6.select)(
1279	store
1280	).getFormatTypeForClassName(settings.className);
1281	if (formatTypeForClassName) {
1282	window.console.error(
1283	`Format "${formatTypeForClassName.name}" is already registered to handle class name "${settings.className}".`
1284	);
1285	return;
1286	}
1287	}
1288	if (!("title" in settings) \|\| settings.title === "") {
1289	window.console.error(
1290	'The format "' + settings.name + '" must have a title.'
1291	);
1292	return;
1293	}
1294	if ("keywords" in settings && settings.keywords.length > 3) {
1295	window.console.error(
1296	'The format "' + settings.name + '" can have a maximum of 3 keywords.'
1297	);
1298	return;
1299	}
1300	if (typeof settings.title !== "string") {
1301	window.console.error("Format titles must be strings.");
1302	return;
1303	}
1304	(0, import_data6.dispatch)(store).addFormatTypes(settings);
1305	return settings;
1306	}
1307
1308	// packages/rich-text/build-module/remove-format.mjs
1309	function removeFormat(value, formatType, startIndex = value.start, endIndex = value.end) {
1310	const { formats, activeFormats } = value;
1311	const newFormats = formats.slice();
1312	if (startIndex === endIndex) {
1313	const format = newFormats[startIndex]?.find(
1314	({ type }) => type === formatType
1315	);
1316	if (format) {
1317	while (newFormats[startIndex]?.find(
1318	(newFormat) => newFormat === format
1319	)) {
1320	filterFormats(newFormats, startIndex, formatType);
1321	startIndex--;
1322	}
1323	endIndex++;
1324	while (newFormats[endIndex]?.find(
1325	(newFormat) => newFormat === format
1326	)) {
1327	filterFormats(newFormats, endIndex, formatType);
1328	endIndex++;
1329	}
1330	}
1331	} else {
1332	for (let i2 = startIndex; i2 < endIndex; i2++) {
1333	if (newFormats[i2]) {
1334	filterFormats(newFormats, i2, formatType);
1335	}
1336	}
1337	}
1338	return normaliseFormats({
1339	...value,
1340	formats: newFormats,
1341	activeFormats: activeFormats?.filter(({ type }) => type !== formatType) \|\| []
1342	});
1343	}
1344	function filterFormats(formats, index, formatType) {
1345	const newFormats = formats[index].filter(
1346	({ type }) => type !== formatType
1347	);
1348	if (newFormats.length) {
1349	formats[index] = newFormats;
1350	} else {
1351	delete formats[index];
1352	}
1353	}
1354
1355	// packages/rich-text/build-module/insert.mjs
1356	function insert(value, valueToInsert, startIndex = value.start, endIndex = value.end) {
1357	const { formats, replacements, text } = value;
1358	if (typeof valueToInsert === "string") {
1359	valueToInsert = create({ text: valueToInsert });
1360	}
1361	const index = startIndex + valueToInsert.text.length;
1362	return normaliseFormats({
1363	formats: formats.slice(0, startIndex).concat(valueToInsert.formats, formats.slice(endIndex)),
1364	replacements: replacements.slice(0, startIndex).concat(
1365	valueToInsert.replacements,
1366	replacements.slice(endIndex)
1367	),
1368	text: text.slice(0, startIndex) + valueToInsert.text + text.slice(endIndex),
1369	start: index,
1370	end: index
1371	});
1372	}
1373
1374	// packages/rich-text/build-module/remove.mjs
1375	function remove2(value, startIndex, endIndex) {
1376	return insert(value, create(), startIndex, endIndex);
1377	}
1378
1379	// packages/rich-text/build-module/replace.mjs
1380	function replace2({ formats, replacements, text, start, end }, pattern, replacement) {
1381	text = text.replace(pattern, (match, ...rest) => {
1382	const offset = rest[rest.length - 2];
1383	let newText = replacement;
1384	let newFormats;
1385	let newReplacements;
1386	if (typeof newText === "function") {
1387	newText = replacement(match, ...rest);
1388	}
1389	if (typeof newText === "object") {
1390	newFormats = newText.formats;
1391	newReplacements = newText.replacements;
1392	newText = newText.text;
1393	} else {
1394	newFormats = Array(newText.length);
1395	newReplacements = Array(newText.length);
1396	if (formats[offset]) {
1397	newFormats = newFormats.fill(formats[offset]);
1398	}
1399	}
1400	formats = formats.slice(0, offset).concat(newFormats, formats.slice(offset + match.length));
1401	replacements = replacements.slice(0, offset).concat(
1402	newReplacements,
1403	replacements.slice(offset + match.length)
1404	);
1405	if (start) {
1406	start = end = offset + newText.length;
1407	}
1408	return newText;
1409	});
1410	return normaliseFormats({ formats, replacements, text, start, end });
1411	}
1412
1413	// packages/rich-text/build-module/insert-object.mjs
1414	function insertObject(value, formatToInsert, startIndex, endIndex) {
1415	const valueToInsert = {
1416	formats: [,],
1417	replacements: [formatToInsert],
1418	text: OBJECT_REPLACEMENT_CHARACTER
1419	};
1420	return insert(value, valueToInsert, startIndex, endIndex);
1421	}
1422
1423	// packages/rich-text/build-module/slice.mjs
1424	function slice(value, startIndex = value.start, endIndex = value.end) {
1425	const { formats, replacements, text } = value;
1426	if (startIndex === void 0 \|\| endIndex === void 0) {
1427	return { ...value };
1428	}
1429	return {
1430	formats: formats.slice(startIndex, endIndex),
1431	replacements: replacements.slice(startIndex, endIndex),
1432	text: text.slice(startIndex, endIndex)
1433	};
1434	}
1435
1436	// packages/rich-text/build-module/split.mjs
1437	function split({ formats, replacements, text, start, end }, string) {
1438	if (typeof string !== "string") {
1439	return splitAtSelection(...arguments);
1440	}
1441	let nextStart = 0;
1442	return text.split(string).map((substring) => {
1443	const startIndex = nextStart;
1444	const value = {
1445	formats: formats.slice(startIndex, startIndex + substring.length),
1446	replacements: replacements.slice(
1447	startIndex,
1448	startIndex + substring.length
1449	),
1450	text: substring
1451	};
1452	nextStart += string.length + substring.length;
1453	if (start !== void 0 && end !== void 0) {
1454	if (start >= startIndex && start < nextStart) {
1455	value.start = start - startIndex;
1456	} else if (start < startIndex && end > startIndex) {
1457	value.start = 0;
1458	}
1459	if (end >= startIndex && end < nextStart) {
1460	value.end = end - startIndex;
1461	} else if (start < nextStart && end > nextStart) {
1462	value.end = substring.length;
1463	}
1464	}
1465	return value;
1466	});
1467	}
1468	function splitAtSelection({ formats, replacements, text, start, end }, startIndex = start, endIndex = end) {
1469	if (start === void 0 \|\| end === void 0) {
1470	return;
1471	}
1472	const before = {
1473	formats: formats.slice(0, startIndex),
1474	replacements: replacements.slice(0, startIndex),
1475	text: text.slice(0, startIndex)
1476	};
1477	const after = {
1478	formats: formats.slice(endIndex),
1479	replacements: replacements.slice(endIndex),
1480	text: text.slice(endIndex),
1481	start: 0,
1482	end: 0
1483	};
1484	return [before, after];
1485	}
1486
1487	// packages/rich-text/build-module/is-range-equal.mjs
1488	function isRangeEqual(a2, b2) {
1489	return a2 === b2 \|\| a2 && b2 && a2.startContainer === b2.startContainer && a2.startOffset === b2.startOffset && a2.endContainer === b2.endContainer && a2.endOffset === b2.endOffset;
1490	}
1491
1492	// packages/rich-text/build-module/to-dom.mjs
1493	var MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
1494	function createPathToNode(node, rootNode, path) {
1495	const parentNode = node.parentNode;
1496	let i2 = 0;
1497	while (node = node.previousSibling) {
1498	i2++;
1499	}
1500	path = [i2, ...path];
1501	if (parentNode !== rootNode) {
1502	path = createPathToNode(parentNode, rootNode, path);
1503	}
1504	return path;
1505	}
1506	function getNodeByPath(node, path) {
1507	path = [...path];
1508	while (node && path.length > 1) {
1509	node = node.childNodes[path.shift()];
1510	}
1511	return {
1512	node,
1513	offset: path[0]
1514	};
1515	}
1516	function append2(element, child) {
1517	if (child.html !== void 0) {
1518	return element.innerHTML += child.html;
1519	}
1520	if (typeof child === "string") {
1521	child = element.ownerDocument.createTextNode(child);
1522	}
1523	const { type, attributes } = child;
1524	if (type) {
1525	if (type === "#comment") {
1526	child = element.ownerDocument.createComment(
1527	attributes["data-rich-text-comment"]
1528	);
1529	} else {
1530	const parentNamespace = element.namespaceURI;
1531	if (type === "math") {
1532	child = element.ownerDocument.createElementNS(
1533	MATHML_NAMESPACE,
1534	type
1535	);
1536	} else if (parentNamespace === MATHML_NAMESPACE) {
1537	if (element.tagName === "MTEXT") {
1538	child = element.ownerDocument.createElement(type);
1539	} else {
1540	child = element.ownerDocument.createElementNS(
1541	MATHML_NAMESPACE,
1542	type
1543	);
1544	}
1545	} else {
1546	child = element.ownerDocument.createElement(type);
1547	}
1548	for (const key in attributes) {
1549	child.setAttribute(key, attributes[key]);
1550	}
1551	}
1552	}
1553	return element.appendChild(child);
1554	}
1555	function appendText2(node, text) {
1556	node.appendData(text);
1557	}
1558	function getLastChild2({ lastChild }) {
1559	return lastChild;
1560	}
1561	function getParent2({ parentNode }) {
1562	return parentNode;
1563	}
1564	function isText2(node) {
1565	return node.nodeType === node.TEXT_NODE;
1566	}
1567	function getText2({ nodeValue }) {
1568	return nodeValue;
1569	}
1570	function remove3(node) {
1571	return node.parentNode.removeChild(node);
1572	}
1573	function toDom({
1574	value,
1575	prepareEditableTree,
1576	isEditableTree = true,
1577	placeholder,
1578	doc = document
1579	}) {
1580	let startPath = [];
1581	let endPath = [];
1582	if (prepareEditableTree) {
1583	value = {
1584	...value,
1585	formats: prepareEditableTree(value)
1586	};
1587	}
1588	const createEmpty2 = () => createElement(doc, "");
1589	const tree = toTree({
1590	value,
1591	createEmpty: createEmpty2,
1592	append: append2,
1593	getLastChild: getLastChild2,
1594	getParent: getParent2,
1595	isText: isText2,
1596	getText: getText2,
1597	remove: remove3,
1598	appendText: appendText2,
1599	onStartIndex(body, pointer) {
1600	startPath = createPathToNode(pointer, body, [
1601	pointer.nodeValue.length
1602	]);
1603	},
1604	onEndIndex(body, pointer) {
1605	endPath = createPathToNode(pointer, body, [
1606	pointer.nodeValue.length
1607	]);
1608	},
1609	isEditableTree,
1610	placeholder
1611	});
1612	return {
1613	body: tree,
1614	selection: { startPath, endPath }
1615	};
1616	}
1617	function apply({
1618	value,
1619	current,
1620	prepareEditableTree,
1621	__unstableDomOnly,
1622	placeholder
1623	}) {
1624	const { body, selection } = toDom({
1625	value,
1626	prepareEditableTree,
1627	placeholder,
1628	doc: current.ownerDocument
1629	});
1630	applyValue(body, current);
1631	if (value.start !== void 0 && !__unstableDomOnly) {
1632	applySelection(selection, current);
1633	}
1634	}
1635	function applyValue(future, current) {
1636	let i2 = 0;
1637	let futureChild;
1638	while (futureChild = future.firstChild) {
1639	const currentChild = current.childNodes[i2];
1640	if (!currentChild) {
1641	current.appendChild(futureChild);
1642	} else if (!currentChild.isEqualNode(futureChild)) {
1643	if (currentChild.nodeName !== futureChild.nodeName \|\| currentChild.nodeType === currentChild.TEXT_NODE && currentChild.data !== futureChild.data) {
1644	current.replaceChild(futureChild, currentChild);
1645	} else {
1646	const currentAttributes = currentChild.attributes;
1647	const futureAttributes = futureChild.attributes;
1648	if (currentAttributes) {
1649	let ii = currentAttributes.length;
1650	while (ii--) {
1651	const { name } = currentAttributes[ii];
1652	if (!futureChild.getAttribute(name)) {
1653	currentChild.removeAttribute(name);
1654	}
1655	}
1656	}
1657	if (futureAttributes) {
1658	for (let ii = 0; ii < futureAttributes.length; ii++) {
1659	const { name, value } = futureAttributes[ii];
1660	if (currentChild.getAttribute(name) !== value) {
1661	currentChild.setAttribute(name, value);
1662	}
1663	}
1664	}
1665	applyValue(futureChild, currentChild);
1666	future.removeChild(futureChild);
1667	}
1668	} else {
1669	future.removeChild(futureChild);
1670	}
1671	i2++;
1672	}
1673	while (current.childNodes[i2]) {
1674	current.removeChild(current.childNodes[i2]);
1675	}
1676	}
1677	function applySelection({ startPath, endPath }, current) {
1678	const { node: startContainer, offset: startOffset } = getNodeByPath(
1679	current,
1680	startPath
1681	);
1682	const { node: endContainer, offset: endOffset } = getNodeByPath(
1683	current,
1684	endPath
1685	);
1686	const { ownerDocument } = current;
1687	const { defaultView } = ownerDocument;
1688	const selection = defaultView.getSelection();
1689	const range = ownerDocument.createRange();
1690	range.setStart(startContainer, startOffset);
1691	range.setEnd(endContainer, endOffset);
1692	const { activeElement } = ownerDocument;
1693	if (selection.rangeCount > 0) {
1694	if (isRangeEqual(range, selection.getRangeAt(0))) {
1695	return;
1696	}
1697	selection.removeAllRanges();
1698	}
1699	selection.addRange(range);
1700	if (activeElement !== ownerDocument.activeElement) {
1701	if (activeElement instanceof defaultView.HTMLElement) {
1702	activeElement.focus();
1703	}
1704	}
1705	}
1706
1707	// packages/rich-text/build-module/toggle-format.mjs
1708	var import_a11y = __toESM(require_a11y(), 1);
1709	var import_i18n = __toESM(require_i18n(), 1);
1710	function toggleFormat(value, format) {
1711	if (getActiveFormat(value, format.type)) {
1712	if (format.title) {
1713	(0, import_a11y.speak)((0, import_i18n.sprintf)((0, import_i18n.__)("%s removed."), format.title), "assertive");
1714	}
1715	return removeFormat(value, format.type);
1716	}
1717	if (format.title) {
1718	(0, import_a11y.speak)((0, import_i18n.sprintf)((0, import_i18n.__)("%s applied."), format.title), "assertive");
1719	}
1720	return applyFormat(value, format);
1721	}
1722
1723	// packages/rich-text/build-module/unregister-format-type.mjs
1724	var import_data7 = __toESM(require_data(), 1);
1725	function unregisterFormatType(name) {
1726	const oldFormat = (0, import_data7.select)(store).getFormatType(name);
1727	if (!oldFormat) {
1728	window.console.error(`Format ${name} is not registered.`);
1729	return;
1730	}
1731	(0, import_data7.dispatch)(store).removeFormatTypes(name);
1732	return oldFormat;
1733	}
1734
1735	// packages/rich-text/build-module/lock-unlock.mjs
1736	var import_private_apis = __toESM(require_private_apis(), 1);
1737	var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
1738	"I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
1739	"@wordpress/rich-text"
1740	);
1741
1742	// packages/rich-text/build-module/hook/index.mjs
1743	var import_element5 = __toESM(require_element(), 1);
1744	var import_compose9 = __toESM(require_compose(), 1);
1745	var import_data9 = __toESM(require_data(), 1);
1746	var import_deprecated = __toESM(require_deprecated(), 1);
1747
1748	// packages/rich-text/build-module/hook/use-default-style.mjs
1749	var import_element = __toESM(require_element(), 1);
1750	var whiteSpace = "pre-wrap";
1751	function useDefaultStyle() {
1752	return (0, import_element.useCallback)((element) => {
1753	if (!element) {
1754	return;
1755	}
1756	element.style.whiteSpace = element.style.whiteSpace \|\| whiteSpace;
1757	}, []);
1758	}
1759
1760	// node_modules/colord/index.mjs
1761	var r = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) };
1762	var t = function(r2) {
1763	return "string" == typeof r2 ? r2.length > 0 : "number" == typeof r2;
1764	};
1765	var n = function(r2, t2, n2) {
1766	return void 0 === t2 && (t2 = 0), void 0 === n2 && (n2 = Math.pow(10, t2)), Math.round(n2 * r2) / n2 + 0;
1767	};
1768	var e = function(r2, t2, n2) {
1769	return void 0 === t2 && (t2 = 0), void 0 === n2 && (n2 = 1), r2 > n2 ? n2 : r2 > t2 ? r2 : t2;
1770	};
1771	var u = function(r2) {
1772	return (r2 = isFinite(r2) ? r2 % 360 : 0) > 0 ? r2 : r2 + 360;
1773	};
1774	var a = function(r2) {
1775	return { r: e(r2.r, 0, 255), g: e(r2.g, 0, 255), b: e(r2.b, 0, 255), a: e(r2.a) };
1776	};
1777	var o = function(r2) {
1778	return { r: n(r2.r), g: n(r2.g), b: n(r2.b), a: n(r2.a, 3) };
1779	};
1780	var i = /^#([0-9a-f]{3,8})$/i;
1781	var s = function(r2) {
1782	var t2 = r2.toString(16);
1783	return t2.length < 2 ? "0" + t2 : t2;
1784	};
1785	var h = function(r2) {
1786	var t2 = r2.r, n2 = r2.g, e2 = r2.b, u2 = r2.a, a2 = Math.max(t2, n2, e2), o2 = a2 - Math.min(t2, n2, e2), i2 = o2 ? a2 === t2 ? (n2 - e2) / o2 : a2 === n2 ? 2 + (e2 - t2) / o2 : 4 + (t2 - n2) / o2 : 0;
1787	return { h: 60 * (i2 < 0 ? i2 + 6 : i2), s: a2 ? o2 / a2 * 100 : 0, v: a2 / 255 * 100, a: u2 };
1788	};
1789	var b = function(r2) {
1790	var t2 = r2.h, n2 = r2.s, e2 = r2.v, u2 = r2.a;
1791	t2 = t2 / 360 * 6, n2 /= 100, e2 /= 100;
1792	var a2 = Math.floor(t2), o2 = e2 * (1 - n2), i2 = e2 * (1 - (t2 - a2) * n2), s2 = e2 * (1 - (1 - t2 + a2) * n2), h2 = a2 % 6;
1793	return { r: 255 * [e2, i2, o2, o2, s2, e2][h2], g: 255 * [s2, e2, e2, i2, o2, o2][h2], b: 255 * [o2, o2, s2, e2, e2, i2][h2], a: u2 };
1794	};
1795	var g = function(r2) {
1796	return { h: u(r2.h), s: e(r2.s, 0, 100), l: e(r2.l, 0, 100), a: e(r2.a) };
1797	};
1798	var d = function(r2) {
1799	return { h: n(r2.h), s: n(r2.s), l: n(r2.l), a: n(r2.a, 3) };
1800	};
1801	var f = function(r2) {
1802	return b((n2 = (t2 = r2).s, { h: t2.h, s: (n2 = ((e2 = t2.l) < 50 ? e2 : 100 - e2) / 100) > 0 ? 2 n2 / (e2 + n2) * 100 : 0, v: e2 + n2, a: t2.a }));
1803	var t2, n2, e2;
1804	};
1805	var c = function(r2) {
1806	return { h: (t2 = h(r2)).h, s: (u2 = (200 - (n2 = t2.s)) * (e2 = t2.v) / 100) > 0 && u2 < 200 ? n2 * e2 / 100 / (u2 <= 100 ? u2 : 200 - u2) * 100 : 0, l: u2 / 2, a: t2.a };
1807	var t2, n2, e2, u2;
1808	};
1809	var l = /^hsla?\(\s([+-]?\d\.?\d+)(deg\|rad\|grad\|turn)?\s,\s([+-]?\d\.?\d+)%\s,\s([+-]?\d\.?\d+)%\s(?:,\s([+-]?\d\.?\d+)(%)?\s)?\)$/i;
1810	var p = /^hsla?\(\s([+-]?\d\.?\d+)(deg\|rad\|grad\|turn)?\s+([+-]?\d\.?\d+)%\s+([+-]?\d\.?\d+)%\s(?:\/\s([+-]?\d\.?\d+)(%)?\s)?\)$/i;
1811	var v = /^rgba?\(\s([+-]?\d\.?\d+)(%)?\s,\s([+-]?\d\.?\d+)(%)?\s,\s([+-]?\d\.?\d+)(%)?\s(?:,\s([+-]?\d\.?\d+)(%)?\s)?\)$/i;
1812	var m = /^rgba?\(\s([+-]?\d\.?\d+)(%)?\s+([+-]?\d\.?\d+)(%)?\s+([+-]?\d\.?\d+)(%)?\s(?:\/\s([+-]?\d\.?\d+)(%)?\s)?\)$/i;
1813	var y = { string: [[function(r2) {
1814	var t2 = i.exec(r2);
1815	return t2 ? (r2 = t2[1]).length <= 4 ? { r: parseInt(r2[0] + r2[0], 16), g: parseInt(r2[1] + r2[1], 16), b: parseInt(r2[2] + r2[2], 16), a: 4 === r2.length ? n(parseInt(r2[3] + r2[3], 16) / 255, 2) : 1 } : 6 === r2.length \|\| 8 === r2.length ? { r: parseInt(r2.substr(0, 2), 16), g: parseInt(r2.substr(2, 2), 16), b: parseInt(r2.substr(4, 2), 16), a: 8 === r2.length ? n(parseInt(r2.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
1816	}, "hex"], [function(r2) {
1817	var t2 = v.exec(r2) \|\| m.exec(r2);
1818	return t2 ? t2[2] !== t2[4] \|\| t2[4] !== t2[6] ? null : a({ r: Number(t2[1]) / (t2[2] ? 100 / 255 : 1), g: Number(t2[3]) / (t2[4] ? 100 / 255 : 1), b: Number(t2[5]) / (t2[6] ? 100 / 255 : 1), a: void 0 === t2[7] ? 1 : Number(t2[7]) / (t2[8] ? 100 : 1) }) : null;
1819	}, "rgb"], [function(t2) {
1820	var n2 = l.exec(t2) \|\| p.exec(t2);
1821	if (!n2) return null;
1822	var e2, u2, a2 = g({ h: (e2 = n2[1], u2 = n2[2], void 0 === u2 && (u2 = "deg"), Number(e2) * (r[u2] \|\| 1)), s: Number(n2[3]), l: Number(n2[4]), a: void 0 === n2[5] ? 1 : Number(n2[5]) / (n2[6] ? 100 : 1) });
1823	return f(a2);
1824	}, "hsl"]], object: [[function(r2) {
1825	var n2 = r2.r, e2 = r2.g, u2 = r2.b, o2 = r2.a, i2 = void 0 === o2 ? 1 : o2;
1826	return t(n2) && t(e2) && t(u2) ? a({ r: Number(n2), g: Number(e2), b: Number(u2), a: Number(i2) }) : null;
1827	}, "rgb"], [function(r2) {
1828	var n2 = r2.h, e2 = r2.s, u2 = r2.l, a2 = r2.a, o2 = void 0 === a2 ? 1 : a2;
1829	if (!t(n2) \|\| !t(e2) \|\| !t(u2)) return null;
1830	var i2 = g({ h: Number(n2), s: Number(e2), l: Number(u2), a: Number(o2) });
1831	return f(i2);
1832	}, "hsl"], [function(r2) {
1833	var n2 = r2.h, a2 = r2.s, o2 = r2.v, i2 = r2.a, s2 = void 0 === i2 ? 1 : i2;
1834	if (!t(n2) \|\| !t(a2) \|\| !t(o2)) return null;
1835	var h2 = (function(r3) {
1836	return { h: u(r3.h), s: e(r3.s, 0, 100), v: e(r3.v, 0, 100), a: e(r3.a) };
1837	})({ h: Number(n2), s: Number(a2), v: Number(o2), a: Number(s2) });
1838	return b(h2);
1839	}, "hsv"]] };
1840	var N = function(r2, t2) {
1841	for (var n2 = 0; n2 < t2.length; n2++) {
1842	var e2 = t2[n2][0](r2);
1843	if (e2) return [e2, t2[n2][1]];
1844	}
1845	return [null, void 0];
1846	};
1847	var x = function(r2) {
1848	return "string" == typeof r2 ? N(r2.trim(), y.string) : "object" == typeof r2 && null !== r2 ? N(r2, y.object) : [null, void 0];
1849	};
1850	var M = function(r2, t2) {
1851	var n2 = c(r2);
1852	return { h: n2.h, s: e(n2.s + 100 * t2, 0, 100), l: n2.l, a: n2.a };
1853	};
1854	var H = function(r2) {
1855	return (299 * r2.r + 587 * r2.g + 114 * r2.b) / 1e3 / 255;
1856	};
1857	var $ = function(r2, t2) {
1858	var n2 = c(r2);
1859	return { h: n2.h, s: n2.s, l: e(n2.l + 100 * t2, 0, 100), a: n2.a };
1860	};
1861	var j = (function() {
1862	function r2(r3) {
1863	this.parsed = x(r3)[0], this.rgba = this.parsed \|\| { r: 0, g: 0, b: 0, a: 1 };
1864	}
1865	return r2.prototype.isValid = function() {
1866	return null !== this.parsed;
1867	}, r2.prototype.brightness = function() {
1868	return n(H(this.rgba), 2);
1869	}, r2.prototype.isDark = function() {
1870	return H(this.rgba) < 0.5;
1871	}, r2.prototype.isLight = function() {
1872	return H(this.rgba) >= 0.5;
1873	}, r2.prototype.toHex = function() {
1874	return r3 = o(this.rgba), t2 = r3.r, e2 = r3.g, u2 = r3.b, i2 = (a2 = r3.a) < 1 ? s(n(255 * a2)) : "", "#" + s(t2) + s(e2) + s(u2) + i2;
1875	var r3, t2, e2, u2, a2, i2;
1876	}, r2.prototype.toRgb = function() {
1877	return o(this.rgba);
1878	}, r2.prototype.toRgbString = function() {
1879	return r3 = o(this.rgba), t2 = r3.r, n2 = r3.g, e2 = r3.b, (u2 = r3.a) < 1 ? "rgba(" + t2 + ", " + n2 + ", " + e2 + ", " + u2 + ")" : "rgb(" + t2 + ", " + n2 + ", " + e2 + ")";
1880	var r3, t2, n2, e2, u2;
1881	}, r2.prototype.toHsl = function() {
1882	return d(c(this.rgba));
1883	}, r2.prototype.toHslString = function() {
1884	return r3 = d(c(this.rgba)), t2 = r3.h, n2 = r3.s, e2 = r3.l, (u2 = r3.a) < 1 ? "hsla(" + t2 + ", " + n2 + "%, " + e2 + "%, " + u2 + ")" : "hsl(" + t2 + ", " + n2 + "%, " + e2 + "%)";
1885	var r3, t2, n2, e2, u2;
1886	}, r2.prototype.toHsv = function() {
1887	return r3 = h(this.rgba), { h: n(r3.h), s: n(r3.s), v: n(r3.v), a: n(r3.a, 3) };
1888	var r3;
1889	}, r2.prototype.invert = function() {
1890	return w({ r: 255 - (r3 = this.rgba).r, g: 255 - r3.g, b: 255 - r3.b, a: r3.a });
1891	var r3;
1892	}, r2.prototype.saturate = function(r3) {
1893	return void 0 === r3 && (r3 = 0.1), w(M(this.rgba, r3));
1894	}, r2.prototype.desaturate = function(r3) {
1895	return void 0 === r3 && (r3 = 0.1), w(M(this.rgba, -r3));
1896	}, r2.prototype.grayscale = function() {
1897	return w(M(this.rgba, -1));
1898	}, r2.prototype.lighten = function(r3) {
1899	return void 0 === r3 && (r3 = 0.1), w($(this.rgba, r3));
1900	}, r2.prototype.darken = function(r3) {
1901	return void 0 === r3 && (r3 = 0.1), w($(this.rgba, -r3));
1902	}, r2.prototype.rotate = function(r3) {
1903	return void 0 === r3 && (r3 = 15), this.hue(this.hue() + r3);
1904	}, r2.prototype.alpha = function(r3) {
1905	return "number" == typeof r3 ? w({ r: (t2 = this.rgba).r, g: t2.g, b: t2.b, a: r3 }) : n(this.rgba.a, 3);
1906	var t2;
1907	}, r2.prototype.hue = function(r3) {
1908	var t2 = c(this.rgba);
1909	return "number" == typeof r3 ? w({ h: r3, s: t2.s, l: t2.l, a: t2.a }) : n(t2.h);
1910	}, r2.prototype.isEqual = function(r3) {
1911	return this.toHex() === w(r3).toHex();
1912	}, r2;
1913	})();
1914	var w = function(r2) {
1915	return r2 instanceof j ? r2 : new j(r2);
1916	};
1917
1918	// packages/rich-text/build-module/hook/use-boundary-style.mjs
1919	var import_element2 = __toESM(require_element(), 1);
1920	function useBoundaryStyle({ record }) {
1921	const ref = (0, import_element2.useRef)();
1922	const { activeFormats = [], replacements, start } = record.current;
1923	const activeReplacement = replacements[start];
1924	(0, import_element2.useEffect)(() => {
1925	if ((!activeFormats \|\| !activeFormats.length) && !activeReplacement) {
1926	return;
1927	}
1928	const boundarySelector = "*[data-rich-text-format-boundary]";
1929	const element = ref.current.querySelector(boundarySelector);
1930	if (!element) {
1931	return;
1932	}
1933	const { ownerDocument } = element;
1934	const { defaultView } = ownerDocument;
1935	const computedStyle = defaultView.getComputedStyle(element);
1936	const newColor = w(computedStyle.color).alpha(0.2).toRgbString();
1937	const selector = `.rich-text:focus ${boundarySelector}`;
1938	const rule = `background-color: ${newColor}`;
1939	const style = `${selector} {${rule}}`;
1940	const globalStyleId = "rich-text-boundary-style";
1941	let globalStyle = ownerDocument.getElementById(globalStyleId);
1942	if (!globalStyle) {
1943	globalStyle = ownerDocument.createElement("style");
1944	globalStyle.id = globalStyleId;
1945	ownerDocument.head.appendChild(globalStyle);
1946	}
1947	if (globalStyle.innerHTML !== style) {
1948	globalStyle.innerHTML = style;
1949	}
1950	}, [activeFormats, activeReplacement]);
1951	return ref;
1952	}
1953
1954	// packages/rich-text/build-module/hook/event-listeners/index.mjs
1955	var import_element3 = __toESM(require_element(), 1);
1956	var import_compose8 = __toESM(require_compose(), 1);
1957
1958	// packages/rich-text/build-module/hook/event-listeners/copy-handler.mjs
1959	var import_compose = __toESM(require_compose(), 1);
1960	var { subscribeDelegatedListener } = unlock(import_compose.privateApis);
1961	var copy_handler_default = (props) => (element) => {
1962	function onCopy(event) {
1963	const { record } = props.current;
1964	const { ownerDocument } = element;
1965	if (isCollapsed(record.current) \|\| !element.contains(ownerDocument.activeElement)) {
1966	return;
1967	}
1968	const selectedRecord = slice(record.current);
1969	const plainText = getTextContent(selectedRecord);
1970	const html = toHTMLString({ value: selectedRecord });
1971	event.clipboardData.setData("text/plain", plainText);
1972	event.clipboardData.setData("text/html", html);
1973	event.clipboardData.setData("rich-text", "true");
1974	event.preventDefault();
1975	if (event.type === "cut") {
1976	ownerDocument.execCommand("delete");
1977	}
1978	}
1979	const { defaultView } = element.ownerDocument;
1980	const unsubscribeCopy = subscribeDelegatedListener(
1981	defaultView,
1982	"copy",
1983	onCopy
1984	);
1985	const unsubscribeCut = subscribeDelegatedListener(
1986	defaultView,
1987	"cut",
1988	onCopy
1989	);
1990	return () => {
1991	unsubscribeCopy();
1992	unsubscribeCut();
1993	};
1994	};
1995
1996	// packages/rich-text/build-module/hook/event-listeners/select-object.mjs
1997	var import_compose2 = __toESM(require_compose(), 1);
1998	var { subscribeDelegatedListener: subscribeDelegatedListener2 } = unlock(import_compose2.privateApis);
1999	var select_object_default = () => (element) => {
2000	function onClick(event) {
2001	const { target } = event;
2002	if (target === element \|\| target.textContent && target.isContentEditable) {
2003	return;
2004	}
2005	const { ownerDocument } = target;
2006	const { defaultView } = ownerDocument;
2007	const selection = defaultView.getSelection();
2008	if (selection.containsNode(target)) {
2009	return;
2010	}
2011	const range = ownerDocument.createRange();
2012	const nodeToSelect = target.isContentEditable ? target : target.closest("[contenteditable]");
2013	range.selectNode(nodeToSelect);
2014	selection.removeAllRanges();
2015	selection.addRange(range);
2016	event.preventDefault();
2017	}
2018	function onFocusIn(event) {
2019	if (event.relatedTarget && !element.contains(event.relatedTarget) && event.relatedTarget.tagName === "A") {
2020	onClick(event);
2021	}
2022	}
2023	const unsubscribeClick = subscribeDelegatedListener2(
2024	element,
2025	"click",
2026	onClick
2027	);
2028	const unsubscribeFocusIn = subscribeDelegatedListener2(
2029	element,
2030	"focusin",
2031	onFocusIn
2032	);
2033	return () => {
2034	unsubscribeClick();
2035	unsubscribeFocusIn();
2036	};
2037	};
2038
2039	// packages/rich-text/build-module/hook/event-listeners/format-boundaries.mjs
2040	var import_keycodes = __toESM(require_keycodes(), 1);
2041	var import_compose3 = __toESM(require_compose(), 1);
2042	var { subscribeDelegatedListener: subscribeDelegatedListener3 } = unlock(import_compose3.privateApis);
2043	var EMPTY_ACTIVE_FORMATS = [];
2044	var format_boundaries_default = (props) => (element) => {
2045	function onKeyDown(event) {
2046	const { keyCode, shiftKey, altKey, metaKey, ctrlKey } = event;
2047	if (
2048	// Only override left and right keys without modifiers pressed.
2049	shiftKey \|\| altKey \|\| metaKey \|\| ctrlKey \|\| keyCode !== import_keycodes.LEFT && keyCode !== import_keycodes.RIGHT
2050	) {
2051	return;
2052	}
2053	const { record, applyRecord, forceRender } = props.current;
2054	const {
2055	text,
2056	formats,
2057	start,
2058	end,
2059	activeFormats: currentActiveFormats = []
2060	} = record.current;
2061	const collapsed = isCollapsed(record.current);
2062	const { defaultView } = element.ownerDocument;
2063	const { direction } = defaultView.getComputedStyle(element);
2064	const reverseKey = direction === "rtl" ? import_keycodes.RIGHT : import_keycodes.LEFT;
2065	const isReverse = event.keyCode === reverseKey;
2066	if (collapsed && currentActiveFormats.length === 0) {
2067	if (start === 0 && isReverse) {
2068	return;
2069	}
2070	if (end === text.length && !isReverse) {
2071	return;
2072	}
2073	}
2074	if (!collapsed) {
2075	return;
2076	}
2077	const formatsBefore = formats[start - 1] \|\| EMPTY_ACTIVE_FORMATS;
2078	const formatsAfter = formats[start] \|\| EMPTY_ACTIVE_FORMATS;
2079	const destination = isReverse ? formatsBefore : formatsAfter;
2080	const isIncreasing = currentActiveFormats.every(
2081	(format, index) => format === destination[index]
2082	);
2083	let newActiveFormatsLength = currentActiveFormats.length;
2084	if (!isIncreasing) {
2085	newActiveFormatsLength--;
2086	} else if (newActiveFormatsLength < destination.length) {
2087	newActiveFormatsLength++;
2088	}
2089	if (newActiveFormatsLength === currentActiveFormats.length) {
2090	record.current._newActiveFormats = destination;
2091	return;
2092	}
2093	event.preventDefault();
2094	const origin = isReverse ? formatsAfter : formatsBefore;
2095	const source = isIncreasing ? destination : origin;
2096	const newActiveFormats = source.slice(0, newActiveFormatsLength);
2097	const newValue = {
2098	...record.current,
2099	activeFormats: newActiveFormats
2100	};
2101	record.current = newValue;
2102	applyRecord(newValue);
2103	forceRender();
2104	}
2105	return subscribeDelegatedListener3(element, "keydown", onKeyDown, true);
2106	};
2107
2108	// packages/rich-text/build-module/hook/event-listeners/delete.mjs
2109	var import_keycodes2 = __toESM(require_keycodes(), 1);
2110	var import_compose4 = __toESM(require_compose(), 1);
2111	var { subscribeDelegatedListener: subscribeDelegatedListener4 } = unlock(import_compose4.privateApis);
2112	var delete_default = (props) => (element) => {
2113	function onKeyDown(event) {
2114	const { keyCode } = event;
2115	if (event.defaultPrevented) {
2116	return;
2117	}
2118	if (keyCode !== import_keycodes2.DELETE && keyCode !== import_keycodes2.BACKSPACE) {
2119	return;
2120	}
2121	const { createRecord, handleChange } = props.current;
2122	const currentValue = createRecord();
2123	const { start, end, text } = currentValue;
2124	if (start === 0 && end !== 0 && end === text.length) {
2125	handleChange(remove2(currentValue));
2126	event.preventDefault();
2127	}
2128	}
2129	return subscribeDelegatedListener4(element, "keydown", onKeyDown);
2130	};
2131
2132	// packages/rich-text/build-module/hook/event-listeners/input-and-selection.mjs
2133	var import_compose5 = __toESM(require_compose(), 1);
2134
2135	// packages/rich-text/build-module/update-formats.mjs
2136	function updateFormats({ value, start, end, formats }) {
2137	const min = Math.min(start, end);
2138	const max = Math.max(start, end);
2139	const formatsBefore = value.formats[min - 1] \|\| [];
2140	const formatsAfter = value.formats[max] \|\| [];
2141	value.activeFormats = formats.map((format, index) => {
2142	if (formatsBefore[index]) {
2143	if (isFormatEqual(format, formatsBefore[index])) {
2144	return formatsBefore[index];
2145	}
2146	} else if (formatsAfter[index]) {
2147	if (isFormatEqual(format, formatsAfter[index])) {
2148	return formatsAfter[index];
2149	}
2150	}
2151	return format;
2152	});
2153	while (--end >= start) {
2154	if (value.activeFormats.length > 0) {
2155	value.formats[end] = value.activeFormats;
2156	} else {
2157	delete value.formats[end];
2158	}
2159	}
2160	return value;
2161	}
2162
2163	// packages/rich-text/build-module/hook/event-listeners/input-and-selection.mjs
2164	var { subscribeDelegatedListener: subscribeDelegatedListener5 } = unlock(import_compose5.privateApis);
2165	var INSERTION_INPUT_TYPES_TO_IGNORE = /* @__PURE__ */ new Set([
2166	"insertParagraph",
2167	"insertOrderedList",
2168	"insertUnorderedList",
2169	"insertHorizontalRule",
2170	"insertLink"
2171	]);
2172	var EMPTY_ACTIVE_FORMATS2 = [];
2173	var PLACEHOLDER_ATTR_NAME = "data-rich-text-placeholder";
2174	function fixPlaceholderSelection(defaultView) {
2175	const selection = defaultView.getSelection();
2176	const { anchorNode, anchorOffset } = selection;
2177	if (anchorNode.nodeType !== anchorNode.ELEMENT_NODE) {
2178	return;
2179	}
2180	const targetNode = anchorNode.childNodes[anchorOffset];
2181	if (!targetNode \|\| targetNode.nodeType !== targetNode.ELEMENT_NODE \|\| !targetNode.hasAttribute(PLACEHOLDER_ATTR_NAME)) {
2182	return;
2183	}
2184	selection.collapseToStart();
2185	}
2186	var input_and_selection_default = (props) => (element) => {
2187	const { ownerDocument } = element;
2188	const { defaultView } = ownerDocument;
2189	let isComposing = false;
2190	function onInput(event) {
2191	if (isComposing) {
2192	return;
2193	}
2194	let inputType;
2195	if (event) {
2196	inputType = event.inputType;
2197	}
2198	const { record, applyRecord, createRecord, handleChange } = props.current;
2199	if (inputType && (inputType.indexOf("format") === 0 \|\| INSERTION_INPUT_TYPES_TO_IGNORE.has(inputType))) {
2200	applyRecord(record.current);
2201	return;
2202	}
2203	const currentValue = createRecord();
2204	const { start, activeFormats: oldActiveFormats = [] } = record.current;
2205	const clearFormats = !isCollapsed(record.current) && currentValue.start <= start;
2206	const change = updateFormats({
2207	value: currentValue,
2208	start,
2209	end: currentValue.start,
2210	formats: clearFormats ? [] : oldActiveFormats
2211	});
2212	handleChange(change);
2213	}
2214	function handleSelectionChange() {
2215	const { record, applyRecord, createRecord, onSelectionChange } = props.current;
2216	if (element.contentEditable !== "true") {
2217	return;
2218	}
2219	if (ownerDocument.activeElement !== element) {
2220	ownerDocument.removeEventListener(
2221	"selectionchange",
2222	handleSelectionChange
2223	);
2224	return;
2225	}
2226	if (isComposing) {
2227	return;
2228	}
2229	const { start, end, text } = createRecord();
2230	const oldRecord = record.current;
2231	if (text !== oldRecord.text) {
2232	onInput();
2233	return;
2234	}
2235	if (start === oldRecord.start && end === oldRecord.end) {
2236	if (oldRecord.text.length === 0 && start === 0) {
2237	fixPlaceholderSelection(defaultView);
2238	}
2239	return;
2240	}
2241	const newValue = {
2242	...oldRecord,
2243	start,
2244	end,
2245	// _newActiveFormats may be set on arrow key navigation to control
2246	// the right boundary position. If undefined, getActiveFormats will
2247	// give the active formats according to the browser.
2248	activeFormats: oldRecord._newActiveFormats,
2249	_newActiveFormats: void 0
2250	};
2251	const newActiveFormats = getActiveFormats(
2252	newValue,
2253	EMPTY_ACTIVE_FORMATS2
2254	);
2255	newValue.activeFormats = newActiveFormats;
2256	record.current = newValue;
2257	applyRecord(newValue, { domOnly: true });
2258	onSelectionChange(start, end);
2259	}
2260	function onCompositionStart() {
2261	isComposing = true;
2262	ownerDocument.removeEventListener(
2263	"selectionchange",
2264	handleSelectionChange
2265	);
2266	element.querySelector(`[${PLACEHOLDER_ATTR_NAME}]`)?.remove();
2267	}
2268	function onCompositionEnd() {
2269	isComposing = false;
2270	onInput({ inputType: "insertText" });
2271	ownerDocument.addEventListener(
2272	"selectionchange",
2273	handleSelectionChange
2274	);
2275	}
2276	function onFocus(event) {
2277	if (event.target !== element) {
2278	return;
2279	}
2280	if (element.contentEditable !== "true") {
2281	return;
2282	}
2283	const { record, isSelected, onSelectionChange, applyRecord } = props.current;
2284	if (element.parentElement.closest('[contenteditable="true"]')) {
2285	return;
2286	}
2287	if (!isSelected) {
2288	const index = void 0;
2289	record.current = {
2290	...record.current,
2291	start: index,
2292	end: index,
2293	activeFormats: EMPTY_ACTIVE_FORMATS2
2294	};
2295	} else {
2296	applyRecord(record.current, { domOnly: true });
2297	}
2298	onSelectionChange(record.current.start, record.current.end);
2299	window.queueMicrotask(handleSelectionChange);
2300	ownerDocument.addEventListener(
2301	"selectionchange",
2302	handleSelectionChange
2303	);
2304	}
2305	const unsubscribeInput = subscribeDelegatedListener5(
2306	element,
2307	"input",
2308	onInput,
2309	true
2310	);
2311	const unsubscribeCompositionStart = subscribeDelegatedListener5(
2312	element,
2313	"compositionstart",
2314	onCompositionStart
2315	);
2316	const unsubscribeCompositionEnd = subscribeDelegatedListener5(
2317	element,
2318	"compositionend",
2319	onCompositionEnd,
2320	true
2321	);
2322	const unsubscribeFocus = subscribeDelegatedListener5(
2323	element,
2324	"focusin",
2325	onFocus
2326	);
2327	return () => {
2328	unsubscribeInput();
2329	unsubscribeCompositionStart();
2330	unsubscribeCompositionEnd();
2331	unsubscribeFocus();
2332	};
2333	};
2334
2335	// packages/rich-text/build-module/hook/event-listeners/selection-change-compat.mjs
2336	var import_compose6 = __toESM(require_compose(), 1);
2337	var { subscribeDelegatedListener: subscribeDelegatedListener6 } = unlock(import_compose6.privateApis);
2338	var selection_change_compat_default = () => (element) => {
2339	const { ownerDocument } = element;
2340	const { defaultView } = ownerDocument;
2341	const selection = defaultView?.getSelection();
2342	let range;
2343	function getRange() {
2344	return selection.rangeCount ? selection.getRangeAt(0) : null;
2345	}
2346	function onDown(event) {
2347	const type = event.type === "keydown" ? "keyup" : "pointerup";
2348	function onCancel() {
2349	ownerDocument.removeEventListener(type, onUp);
2350	ownerDocument.removeEventListener("selectionchange", onCancel);
2351	ownerDocument.removeEventListener("input", onCancel);
2352	}
2353	function onUp() {
2354	onCancel();
2355	if (isRangeEqual(range, getRange())) {
2356	return;
2357	}
2358	ownerDocument.dispatchEvent(new Event("selectionchange"));
2359	}
2360	ownerDocument.addEventListener(type, onUp);
2361	ownerDocument.addEventListener("selectionchange", onCancel);
2362	ownerDocument.addEventListener("input", onCancel);
2363	range = getRange();
2364	}
2365	const unsubscribePointerDown = subscribeDelegatedListener6(
2366	element,
2367	"pointerdown",
2368	onDown
2369	);
2370	const unsubscribeKeyDown = subscribeDelegatedListener6(
2371	element,
2372	"keydown",
2373	onDown
2374	);
2375	return () => {
2376	unsubscribePointerDown();
2377	unsubscribeKeyDown();
2378	};
2379	};
2380
2381	// packages/rich-text/build-module/hook/event-listeners/prevent-focus-capture.mjs
2382	var import_compose7 = __toESM(require_compose(), 1);
2383	var { subscribeDelegatedListener: subscribeDelegatedListener7 } = unlock(import_compose7.privateApis);
2384	function preventFocusCapture() {
2385	return (element) => {
2386	const { ownerDocument } = element;
2387	const { defaultView } = ownerDocument;
2388	let value = null;
2389	function onPointerDown(event) {
2390	if (event.defaultPrevented) {
2391	return;
2392	}
2393	if (event.target === element) {
2394	return;
2395	}
2396	if (!event.target.contains(element)) {
2397	return;
2398	}
2399	value = element.getAttribute("contenteditable");
2400	element.setAttribute("contenteditable", "false");
2401	defaultView.getSelection().removeAllRanges();
2402	}
2403	function onPointerUp() {
2404	if (value !== null) {
2405	element.setAttribute("contenteditable", value);
2406	value = null;
2407	}
2408	}
2409	const unsubscribePointerDown = subscribeDelegatedListener7(
2410	defaultView,
2411	"pointerdown",
2412	onPointerDown
2413	);
2414	const unsubscribePointerUp = subscribeDelegatedListener7(
2415	defaultView,
2416	"pointerup",
2417	onPointerUp
2418	);
2419	return () => {
2420	unsubscribePointerDown();
2421	unsubscribePointerUp();
2422	};
2423	};
2424	}
2425
2426	// packages/rich-text/build-module/hook/event-listeners/index.mjs
2427	var allEventListeners = [
2428	copy_handler_default,
2429	select_object_default,
2430	format_boundaries_default,
2431	delete_default,
2432	input_and_selection_default,
2433	selection_change_compat_default,
2434	preventFocusCapture
2435	];
2436	function useEventListeners(props) {
2437	const propsRef = (0, import_element3.useRef)(props);
2438	(0, import_element3.useInsertionEffect)(() => {
2439	propsRef.current = props;
2440	});
2441	const refEffects = (0, import_element3.useMemo)(
2442	() => allEventListeners.map((refEffect) => refEffect(propsRef)),
2443	[propsRef]
2444	);
2445	return (0, import_compose8.useRefEffect)(
2446	(element) => {
2447	const cleanups = refEffects.map((effect) => effect(element));
2448	return () => {
2449	cleanups.forEach((cleanup) => cleanup());
2450	};
2451	},
2452	[refEffects]
2453	);
2454	}
2455
2456	// packages/rich-text/build-module/hook/use-format-types.mjs
2457	var import_element4 = __toESM(require_element(), 1);
2458	var import_data8 = __toESM(require_data(), 1);
2459	function formatTypesSelector(select5) {
2460	return select5(store).getFormatTypes();
2461	}
2462	var interactiveContentTags = /* @__PURE__ */ new Set([
2463	"a",
2464	"audio",
2465	"button",
2466	"details",
2467	"embed",
2468	"iframe",
2469	"input",
2470	"label",
2471	"select",
2472	"textarea",
2473	"video"
2474	]);
2475	function prefixSelectKeys(selected, prefix) {
2476	if (typeof selected !== "object") {
2477	return { [prefix]: selected };
2478	}
2479	return Object.fromEntries(
2480	Object.entries(selected).map(([key, value]) => [
2481	`${prefix}.${key}`,
2482	value
2483	])
2484	);
2485	}
2486	function getPrefixedSelectKeys(selected, prefix) {
2487	if (selected[prefix]) {
2488	return selected[prefix];
2489	}
2490	return Object.keys(selected).filter((key) => key.startsWith(prefix + ".")).reduce((accumulator, key) => {
2491	accumulator[key.slice(prefix.length + 1)] = selected[key];
2492	return accumulator;
2493	}, {});
2494	}
2495	function useFormatTypes({
2496	allowedFormats,
2497	withoutInteractiveFormatting,
2498	__unstableFormatTypeHandlerContext
2499	}) {
2500	const allFormatTypes = (0, import_data8.useSelect)(formatTypesSelector, []);
2501	const formatTypes2 = (0, import_element4.useMemo)(() => {
2502	return allFormatTypes.filter(({ name, interactive, tagName }) => {
2503	if (allowedFormats && !allowedFormats.includes(name)) {
2504	return false;
2505	}
2506	if (withoutInteractiveFormatting && (interactive \|\| interactiveContentTags.has(tagName))) {
2507	return false;
2508	}
2509	return true;
2510	});
2511	}, [allFormatTypes, allowedFormats, withoutInteractiveFormatting]);
2512	const keyedSelected = (0, import_data8.useSelect)(
2513	(select5) => formatTypes2.reduce((accumulator, type) => {
2514	if (!type.__experimentalGetPropsForEditableTreePreparation \|\| !__unstableFormatTypeHandlerContext) {
2515	return accumulator;
2516	}
2517	return {
2518	...accumulator,
2519	...prefixSelectKeys(
2520	type.__experimentalGetPropsForEditableTreePreparation(
2521	select5,
2522	__unstableFormatTypeHandlerContext
2523	),
2524	type.name
2525	)
2526	};
2527	}, {}),
2528	[formatTypes2, __unstableFormatTypeHandlerContext]
2529	);
2530	const dispatch3 = (0, import_data8.useDispatch)();
2531	const prepareHandlers = [];
2532	const valueHandlers = [];
2533	const changeHandlers = [];
2534	const dependencies = [];
2535	for (const key in keyedSelected) {
2536	dependencies.push(keyedSelected[key]);
2537	}
2538	formatTypes2.forEach((type) => {
2539	if (type.__experimentalCreatePrepareEditableTree && __unstableFormatTypeHandlerContext) {
2540	const handler = type.__experimentalCreatePrepareEditableTree(
2541	getPrefixedSelectKeys(keyedSelected, type.name),
2542	__unstableFormatTypeHandlerContext
2543	);
2544	if (type.__experimentalCreateOnChangeEditableValue) {
2545	valueHandlers.push(handler);
2546	} else {
2547	prepareHandlers.push(handler);
2548	}
2549	}
2550	if (type.__experimentalCreateOnChangeEditableValue && __unstableFormatTypeHandlerContext) {
2551	let dispatchers = {};
2552	if (type.__experimentalGetPropsForEditableTreeChangeHandler) {
2553	dispatchers = type.__experimentalGetPropsForEditableTreeChangeHandler(
2554	dispatch3,
2555	__unstableFormatTypeHandlerContext
2556	);
2557	}
2558	const selected = getPrefixedSelectKeys(keyedSelected, type.name);
2559	changeHandlers.push(
2560	type.__experimentalCreateOnChangeEditableValue(
2561	{
2562	...typeof selected === "object" ? selected : {},
2563	...dispatchers
2564	},
2565	__unstableFormatTypeHandlerContext
2566	)
2567	);
2568	}
2569	});
2570	return {
2571	formatTypes: formatTypes2,
2572	prepareHandlers,
2573	valueHandlers,
2574	changeHandlers,
2575	dependencies
2576	};
2577	}
2578
2579	// packages/rich-text/build-module/hook/index.mjs
2580	function useRichTextBase({
2581	value = "",
2582	selectionStart,
2583	selectionEnd,
2584	placeholder,
2585	onSelectionChange,
2586	preserveWhiteSpace,
2587	onChange,
2588	__unstableDisableFormats: disableFormats,
2589	__unstableIsSelected: isSelected,
2590	__unstableDependencies = [],
2591	__unstableAfterParse,
2592	__unstableBeforeSerialize,
2593	__unstableAddInvisibleFormats
2594	}) {
2595	const registry = (0, import_data9.useRegistry)();
2596	const [, forceRender] = (0, import_element5.useReducer)(() => ({}));
2597	const ref = (0, import_element5.useRef)();
2598	function createRecord() {
2599	const {
2600	ownerDocument: { defaultView }
2601	} = ref.current;
2602	const selection = defaultView.getSelection();
2603	const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
2604	return create({
2605	element: ref.current,
2606	range,
2607	__unstableIsEditableTree: true
2608	});
2609	}
2610	function applyRecord(newRecord, { domOnly } = {}) {
2611	apply({
2612	value: newRecord,
2613	current: ref.current,
2614	prepareEditableTree: __unstableAddInvisibleFormats,
2615	__unstableDomOnly: domOnly,
2616	placeholder
2617	});
2618	}
2619	const _valueRef = (0, import_element5.useRef)(value);
2620	const recordRef = (0, import_element5.useRef)();
2621	function setRecordFromProps() {
2622	const activeFormats = recordRef.current?.activeFormats;
2623	_valueRef.current = value;
2624	recordRef.current = value;
2625	if (!(value instanceof RichTextData)) {
2626	recordRef.current = value ? RichTextData.fromHTMLString(value, { preserveWhiteSpace }) : RichTextData.empty();
2627	}
2628	recordRef.current = {
2629	text: recordRef.current.text,
2630	formats: recordRef.current.formats,
2631	replacements: recordRef.current.replacements,
2632	activeFormats
2633	};
2634	if (disableFormats) {
2635	recordRef.current.formats = Array(value.length);
2636	recordRef.current.replacements = Array(value.length);
2637	}
2638	if (__unstableAfterParse) {
2639	recordRef.current.formats = __unstableAfterParse(
2640	recordRef.current
2641	);
2642	}
2643	recordRef.current.start = selectionStart;
2644	recordRef.current.end = selectionEnd;
2645	}
2646	const hadSelectionUpdateRef = (0, import_element5.useRef)(false);
2647	if (!recordRef.current) {
2648	hadSelectionUpdateRef.current = isSelected;
2649	setRecordFromProps();
2650	} else if (selectionStart !== recordRef.current.start \|\| selectionEnd !== recordRef.current.end) {
2651	hadSelectionUpdateRef.current = isSelected;
2652	recordRef.current = {
2653	...recordRef.current,
2654	start: selectionStart,
2655	end: selectionEnd,
2656	activeFormats: void 0
2657	};
2658	}
2659	function handleChange(newRecord) {
2660	recordRef.current = newRecord;
2661	applyRecord(newRecord);
2662	if (disableFormats) {
2663	_valueRef.current = newRecord.text;
2664	} else {
2665	const newFormats = __unstableBeforeSerialize ? __unstableBeforeSerialize(newRecord) : newRecord.formats;
2666	newRecord = { ...newRecord, formats: newFormats };
2667	if (typeof value === "string") {
2668	_valueRef.current = toHTMLString({
2669	value: newRecord,
2670	preserveWhiteSpace
2671	});
2672	} else {
2673	_valueRef.current = new RichTextData(newRecord);
2674	}
2675	}
2676	const { start, end, formats, text } = recordRef.current;
2677	registry.batch(() => {
2678	onSelectionChange(start, end);
2679	onChange(_valueRef.current, {
2680	__unstableFormats: formats,
2681	__unstableText: text
2682	});
2683	});
2684	forceRender();
2685	}
2686	function applyFromProps() {
2687	const previousValue = _valueRef.current;
2688	setRecordFromProps();
2689	const contentLengthChanged = previousValue && typeof previousValue === "string" && typeof value === "string" && previousValue.length !== value.length;
2690	const hasFocus = ref.current?.contains(
2691	ref.current.ownerDocument.activeElement
2692	);
2693	const skipSelection = contentLengthChanged && !hasFocus;
2694	applyRecord(recordRef.current, { domOnly: skipSelection });
2695	}
2696	const didMountRef = (0, import_element5.useRef)(false);
2697	(0, import_element5.useLayoutEffect)(() => {
2698	if (didMountRef.current && value !== _valueRef.current) {
2699	applyFromProps();
2700	forceRender();
2701	}
2702	}, [value]);
2703	(0, import_element5.useLayoutEffect)(() => {
2704	if (!hadSelectionUpdateRef.current) {
2705	return;
2706	}
2707	if (ref.current.ownerDocument.activeElement !== ref.current) {
2708	ref.current.focus();
2709	}
2710	applyRecord(recordRef.current);
2711	hadSelectionUpdateRef.current = false;
2712	}, [hadSelectionUpdateRef.current]);
2713	const mergedRefs = (0, import_compose9.useMergeRefs)([
2714	ref,
2715	useDefaultStyle(),
2716	useBoundaryStyle({ record: recordRef }),
2717	useEventListeners({
2718	record: recordRef,
2719	handleChange,
2720	applyRecord,
2721	createRecord,
2722	isSelected,
2723	onSelectionChange,
2724	forceRender
2725	}),
2726	(0, import_compose9.useRefEffect)(() => {
2727	applyFromProps();
2728	didMountRef.current = true;
2729	}, [placeholder, ...__unstableDependencies])
2730	]);
2731	return {
2732	value: recordRef.current,
2733	// A function to get the most recent value so event handlers in
2734	// useRichText implementations have access to it. For example when
2735	// listening to input events, we internally update the state, but this
2736	// state is not yet available to the input event handler because React
2737	// may re-render asynchronously.
2738	getValue: () => recordRef.current,
2739	onChange: handleChange,
2740	ref: mergedRefs
2741	};
2742	}
2743	function useRichText({
2744	allowedFormats,
2745	withoutInteractiveFormatting,
2746	onChange,
2747	__unstableDependencies = [],
2748	__unstableFormatTypeHandlerContext,
2749	...props
2750	}) {
2751	const {
2752	formatTypes: formatTypes2,
2753	prepareHandlers,
2754	valueHandlers,
2755	changeHandlers,
2756	dependencies
2757	} = useFormatTypes({
2758	allowedFormats,
2759	withoutInteractiveFormatting,
2760	__unstableFormatTypeHandlerContext
2761	});
2762	function addEditorOnlyFormats(record) {
2763	return valueHandlers.reduce(
2764	(accumulator, fn) => fn(accumulator, record.text),
2765	record.formats
2766	);
2767	}
2768	function removeEditorOnlyFormats(record) {
2769	formatTypes2.forEach((formatType) => {
2770	if (formatType.__experimentalCreatePrepareEditableTree) {
2771	record = removeFormat(
2772	record,
2773	formatType.name,
2774	0,
2775	record.text.length
2776	);
2777	}
2778	});
2779	return record.formats;
2780	}
2781	function addInvisibleFormats(record) {
2782	return prepareHandlers.reduce(
2783	(accumulator, fn) => fn(accumulator, record.text),
2784	record.formats
2785	);
2786	}
2787	const result = useRichTextBase({
2788	...props,
2789	onChange(value, { __unstableFormats, __unstableText }) {
2790	onChange(value, { __unstableFormats, __unstableText });
2791	Object.values(changeHandlers).forEach((changeHandler) => {
2792	changeHandler(__unstableFormats, __unstableText);
2793	});
2794	},
2795	__unstableDependencies: [...dependencies, ...__unstableDependencies],
2796	__unstableAfterParse: addEditorOnlyFormats,
2797	__unstableBeforeSerialize: removeEditorOnlyFormats,
2798	__unstableAddInvisibleFormats: addInvisibleFormats
2799	});
2800	return { ...result, formatTypes: formatTypes2 };
2801	}
2802	function useDeprecatedRichText(props) {
2803	(0, import_deprecated.default)("`__unstableUseRichText` hook", {
2804	since: "7.0"
2805	});
2806	return useRichTextBase(props);
2807	}
2808
2809	// packages/rich-text/build-module/private-apis.mjs
2810	var privateApis = {};
2811	lock(privateApis, {
2812	useRichText
2813	});
2814
2815	// packages/rich-text/build-module/hook/use-anchor-ref.mjs
2816	var import_element6 = __toESM(require_element(), 1);
2817	var import_deprecated2 = __toESM(require_deprecated(), 1);
2818	function useAnchorRef({ ref, value, settings = {} }) {
2819	(0, import_deprecated2.default)("`useAnchorRef` hook", {
2820	since: "6.1",
2821	alternative: "`useAnchor` hook"
2822	});
2823	const { tagName, className, name } = settings;
2824	const activeFormat = name ? getActiveFormat(value, name) : void 0;
2825	return (0, import_element6.useMemo)(() => {
2826	if (!ref.current) {
2827	return;
2828	}
2829	const {
2830	ownerDocument: { defaultView }
2831	} = ref.current;
2832	const selection = defaultView.getSelection();
2833	if (!selection.rangeCount) {
2834	return;
2835	}
2836	const range = selection.getRangeAt(0);
2837	if (!activeFormat) {
2838	return range;
2839	}
2840	let element = range.startContainer;
2841	element = element.nextElementSibling \|\| element;
2842	while (element.nodeType !== element.ELEMENT_NODE) {
2843	element = element.parentNode;
2844	}
2845	return element.closest(
2846	tagName + (className ? "." + className : "")
2847	);
2848	}, [activeFormat, value.start, value.end, tagName, className]);
2849	}
2850
2851	// packages/rich-text/build-module/hook/use-anchor.mjs
2852	var import_compose10 = __toESM(require_compose(), 1);
2853	var import_element7 = __toESM(require_element(), 1);
2854	var import_dom = __toESM(require_dom(), 1);
2855	function getFormatElement(range, editableContentElement, tagName, className) {
2856	let element = range.startContainer;
2857	if (element.nodeType === element.TEXT_NODE && element instanceof window.Text && range.startOffset === element.length && element.nextSibling) {
2858	element = element.nextSibling;
2859	while (element.firstChild) {
2860	element = element.firstChild;
2861	}
2862	}
2863	if (element.nodeType !== element.ELEMENT_NODE) {
2864	if (!element.parentElement) {
2865	return;
2866	}
2867	element = element.parentElement;
2868	}
2869	if (element === editableContentElement) {
2870	return;
2871	}
2872	if (!editableContentElement.contains(element)) {
2873	return;
2874	}
2875	const selector = tagName + (className ? "." + className : "");
2876	if (!selector) {
2877	return;
2878	}
2879	if (!(element instanceof window.HTMLElement)) {
2880	return;
2881	}
2882	let closestElement = element;
2883	while (closestElement && closestElement !== editableContentElement) {
2884	if (closestElement.matches(selector)) {
2885	return closestElement;
2886	}
2887	closestElement = closestElement.parentElement;
2888	}
2889	return void 0;
2890	}
2891	function createVirtualAnchorElement(range, editableContentElement) {
2892	return {
2893	contextElement: editableContentElement,
2894	getBoundingClientRect() {
2895	if (editableContentElement.contains(range.startContainer)) {
2896	return (0, import_dom.getRectangleFromRange)(range) ?? range.getBoundingClientRect();
2897	}
2898	return editableContentElement.getBoundingClientRect();
2899	}
2900	};
2901	}
2902	function getAnchor(editableContentElement, tagName, className) {
2903	if (!editableContentElement) {
2904	return;
2905	}
2906	const { ownerDocument } = editableContentElement;
2907	const { defaultView } = ownerDocument;
2908	const selection = defaultView?.getSelection();
2909	if (!selection) {
2910	return;
2911	}
2912	if (!selection.rangeCount) {
2913	return;
2914	}
2915	const range = selection.getRangeAt(0);
2916	if (!range \|\| !range.startContainer) {
2917	return;
2918	}
2919	if (!tagName && !className) {
2920	return createVirtualAnchorElement(range, editableContentElement);
2921	}
2922	return getFormatElement(range, editableContentElement, tagName, className) ?? createVirtualAnchorElement(range, editableContentElement);
2923	}
2924	var DEFAULT_SETTINGS = {
2925	tagName: "",
2926	className: ""
2927	};
2928	function useAnchor({
2929	editableContentElement,
2930	settings
2931	}) {
2932	const { tagName, className } = settings ?? DEFAULT_SETTINGS;
2933	const isActive = !!(settings && "isActive" in settings && settings.isActive);
2934	const [anchor, setAnchor] = (0, import_element7.useState)(
2935	() => getAnchor(editableContentElement, tagName, className ?? "")
2936	);
2937	const wasActive = (0, import_compose10.usePrevious)(isActive);
2938	(0, import_element7.useLayoutEffect)(() => {
2939	if (!editableContentElement) {
2940	return;
2941	}
2942	function callback() {
2943	setAnchor(
2944	getAnchor(editableContentElement, tagName, className ?? "")
2945	);
2946	}
2947	function attach() {
2948	ownerDocument.addEventListener("selectionchange", callback);
2949	}
2950	function detach() {
2951	ownerDocument.removeEventListener("selectionchange", callback);
2952	}
2953	const { ownerDocument } = editableContentElement;
2954	if (editableContentElement === ownerDocument.activeElement \|\| // When a link is created, we need to attach the popover to the newly created anchor.
2955	!wasActive && isActive \|\| // Sometimes we're _removing_ an active anchor, such as the inline color popover.
2956	// When we add the color, it switches from a virtual anchor to a `<mark>` element.
2957	// When we _remove_ the color, it switches from a `<mark>` element to a virtual anchor.
2958	wasActive && !isActive) {
2959	setAnchor(
2960	getAnchor(editableContentElement, tagName, className ?? "")
2961	);
2962	attach();
2963	}
2964	editableContentElement.addEventListener("focusin", attach);
2965	editableContentElement.addEventListener("focusout", detach);
2966	return () => {
2967	detach();
2968	editableContentElement.removeEventListener("focusin", attach);
2969	editableContentElement.removeEventListener("focusout", detach);
2970	};
2971	}, [editableContentElement, tagName, className, isActive, wasActive]);
2972	return anchor;
2973	}
2974
2975	// packages/rich-text/build-module/index.mjs
2976	function __experimentalRichText() {
2977	}
2978	return __toCommonJS(index_exports);
2979	})();
2980	//# sourceMappingURL=index.js.map
2981