Elementor Website Builder – more than just a page builder / 4.3.4

Elementor Website Builder – more than just a page builder v4.3.4

elementor / assets / js / packages / editor-canvas / editor-canvas.js

editor-canvas.js in Elementor Website Builder – more than just a page builder 4.3.4, at assets/js/packages/editor-canvas/editor-canvas.js

9,908 lines 363.2 KB

Raw Download Zip

1	(function(_elementor_editor_v1_adapters, _elementor_editor_mcp, _elementor_http_client, _elementor_editor, react, _elementor_editor_documents, _elementor_editor_styles_repository, _elementor_utils, _elementor_editor_elements, _elementor_ui, react_dom, _elementor_editor_interactions, _elementor_editor_responsive, _elementor_editor_styles, _elementor_editor_props, _elementor_editor_notifications, _wordpress_i18n, _elementor_wp_media, _elementor_editor_controls, _elementor_twing, _elementor_schema) {
2
3	//#region \0rolldown/runtime.js
4	var __create = Object.create;
5	var __defProp$4 = Object.defineProperty;
6	var __name = (target, value) => __defProp$4(target, "name", {
7	value,
8	configurable: true
9	});
10	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
11	var __getOwnPropNames = Object.getOwnPropertyNames;
12	var __getProtoOf = Object.getPrototypeOf;
13	var __hasOwnProp = Object.prototype.hasOwnProperty;
14	var __commonJSMin = (cb, mod) => () => (mod \|\| (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
15	var __exportAll = (all, no_symbols) => {
16	let target = {};
17	for (var name in all) {
18	__defProp$4(target, name, {
19	get: all[name],
20	enumerable: true
21	});
22	}
23	if (!no_symbols) {
24	__defProp$4(target, Symbol.toStringTag, { value: "Module" });
25	}
26	return target;
27	};
28	var __copyProps = (to, from, except, desc) => {
29	if (from && typeof from === "object" \|\| typeof from === "function") {
30	for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
31	key = keys[i];
32	if (!__hasOwnProp.call(to, key) && key !== except) {
33	__defProp$4(to, key, {
34	get: ((k) => from[k]).bind(null, key),
35	enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable
36	});
37	}
38	}
39	}
40	return to;
41	};
42	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp$4(target, "default", {
43	value: mod,
44	enumerable: true
45	}) : target, mod));
46
47	//#endregion
48	let react$1 = __toESM(react, 1);
49	react = __toESM(react);
50	react_dom = __toESM(react_dom, 1);
51
52	//#region packages/packages/core/editor-canvas/src/mcp/resources/widgets-schema-resource.ts
53	var CANVAS_SERVER_NAME = "editor-canvas";
54	var WIDGET_SCHEMA_URI = "elementor://widgets/schema/{widgetType}";
55	var WIDGET_SCHEMA_FULL_URI = `${CANVAS_SERVER_NAME}_${WIDGET_SCHEMA_URI}`;
56	var BEST_PRACTICES_URI$1 = "elementor://style/best-practices";
57	var BEST_PRACTICES_FULL_URI = `${CANVAS_SERVER_NAME}_${BEST_PRACTICES_URI$1}`;
58	var MCP_PROXY_URL$4 = "elementor/v1/mcp-proxy";
59	var listWidgetTypes = async () => {
60	const { data } = await (0, _elementor_http_client.httpService)().post(MCP_PROXY_URL$4, {
61	tool: "list-widget-schemas",
62	input: { summary: true }
63	});
64	return (data.data?.widgets ?? []).map((widget) => widget.type);
65	};
66	var fetchWidgetSchema = async (widgetType) => {
67	const { data } = await (0, _elementor_http_client.httpService)().post(MCP_PROXY_URL$4, {
68	tool: "get-widget-schema",
69	input: { widget_type: widgetType }
70	});
71	return data.data ?? {};
72	};
73	var initWidgetsSchemaResource = (reg) => {
74	const { resource } = reg;
75	resource("widget-schema-by-type", new _elementor_editor_mcp.ResourceTemplate(WIDGET_SCHEMA_URI, { list: async () => {
76	return { resources: (await listWidgetTypes()).map((widgetType) => ({
77	uri: `elementor://widgets/schema/${widgetType}`,
78	name: "Widget schema for " + widgetType
79	})) };
80	} }), { description: "PropType schema for the specified widget type" }, async (uri, variables) => {
81	const widgetType = typeof variables.widgetType === "string" ? variables.widgetType : variables.widgetType?.[0];
82	if (!widgetType) throw new Error("No widget type provided.");
83	const schema = await fetchWidgetSchema(widgetType);
84	return { contents: [{
85	uri: uri.toString(),
86	mimeType: "application/json",
87	text: JSON.stringify(schema)
88	}] };
89	});
90	};
91
92	//#endregion
93	//#region packages/packages/core/editor-canvas/src/mcp/resources/breakpoints-resource.ts
94	var BREAKPOINTS_SCHEMA_URI = "elementor://breakpoints/list";
95	var BREAKPOINTS_SCHEMA_FULL_URI = `${CANVAS_SERVER_NAME}_${BREAKPOINTS_SCHEMA_URI}`;
96	var initBreakpointsResource = (reg) => {
97	const { resource, sendResourceUpdated } = reg;
98	const getBreakpointsList = () => {
99	const { breakpoints } = window.elementor?.config?.responsive \|\| {};
100	if (!breakpoints) return [];
101	return Object.values(breakpoints).filter((bp) => bp.is_enabled).map((bp) => {
102	const { direction: constraint, label, value } = bp;
103	return {
104	label,
105	constraint,
106	value
107	};
108	});
109	};
110	const buildResourceResponse = () => ({ contents: [{
111	uri: BREAKPOINTS_SCHEMA_URI,
112	mimeType: "application/json",
113	text: JSON.stringify(getBreakpointsList())
114	}] });
115	resource("breakpoints ", BREAKPOINTS_SCHEMA_URI, { description: "Breakpoints list." }, () => {
116	return buildResourceResponse();
117	});
118	window.addEventListener((0, _elementor_editor_v1_adapters.v1ReadyEvent)().name, () => {
119	sendResourceUpdated({
120	uri: BREAKPOINTS_SCHEMA_URI,
121	...buildResourceResponse()
122	});
123	});
124	};
125
126	//#endregion
127	//#region packages/packages/core/editor-canvas/src/mcp/utils/convert-css-to-atomic.ts
128	var CSS_TO_ATOMIC_URL = "elementor/v1/css-to-atomic";
129	var SINGLE_BLOCK_KEY = "default";
130	var convertBlocks = async (blocks) => {
131	const { data } = await (0, _elementor_http_client.httpService)().post(CSS_TO_ATOMIC_URL, { blocks });
132	return data.data;
133	};
134	var convertStyleBlocksToAtomic = async (styleByName) => convertBlocks(styleByName);
135	var convertCssToAtomic = async (style) => {
136	return (await convertStyleBlocksToAtomic({ [SINGLE_BLOCK_KEY]: style }))[SINGLE_BLOCK_KEY];
137	};
138
139	//#endregion
140	//#region packages/packages/core/editor-canvas/src/components/classes-rename.tsx
141	var ClassesRename = () => {
142	(0, react.useEffect)(() => {
143	const unsubscribe = subscribeToStylesRepository();
144	return () => {
145	unsubscribe();
146	};
147	}, []);
148	return null;
149	};
150	var subscribeToStylesRepository = () => {
151	return _elementor_editor_styles_repository.stylesRepository.subscribe((previous, current) => {
152	if (!previous \|\| !current) return;
153	Object.keys(current).forEach((id) => {
154	if (!(previous[id] && (0, _elementor_utils.hash)(previous[id]) !== (0, _elementor_utils.hash)(current[id]))) return;
155	const previousStyle = previous[id];
156	const currentStyle = current[id];
157	if (previousStyle.label !== currentStyle.label) renameClass(previousStyle.label, currentStyle.label);
158	});
159	});
160	};
161	var renameClass = (oldClassName, newClassName) => {
162	Object.values((0, _elementor_editor_documents.getV1DocumentsManager)().documents).forEach((document) => {
163	document.container.view?.el?.querySelectorAll(`.elementor .${oldClassName}`).forEach((element) => {
164	element.classList.replace(oldClassName, newClassName);
165	});
166	});
167	};
168
169	//#endregion
170	//#region packages/packages/core/editor-canvas/src/hooks/use-element-rect.ts
171	function useElementRect(element) {
172	const [rect, setRect] = (0, react.useState)(new DOMRect(0, 0, 0, 0));
173	const onChange = (0, _elementor_utils.throttle)(() => {
174	setRect(element?.getBoundingClientRect() ?? new DOMRect(0, 0, 0, 0));
175	}, 20, true);
176	useScrollListener({
177	element,
178	onChange
179	});
180	useResizeListener({
181	element,
182	onChange
183	});
184	useMutationsListener({
185	element,
186	onChange
187	});
188	(0, react.useEffect)(() => () => {
189	onChange.cancel();
190	}, [onChange]);
191	return rect;
192	}
193	function useScrollListener({ element, onChange }) {
194	(0, react.useEffect)(() => {
195	if (!element) return;
196	const win = element.ownerDocument?.defaultView;
197	win?.addEventListener("scroll", onChange, { passive: true });
198	return () => {
199	win?.removeEventListener("scroll", onChange);
200	};
201	}, [element, onChange]);
202	}
203	function useResizeListener({ element, onChange }) {
204	(0, react.useEffect)(() => {
205	if (!element) return;
206	const resizeObserver = new ResizeObserver(onChange);
207	resizeObserver.observe(element);
208	const win = element.ownerDocument?.defaultView;
209	win?.addEventListener("resize", onChange, { passive: true });
210	return () => {
211	resizeObserver.disconnect();
212	win?.removeEventListener("resize", onChange);
213	};
214	}, [element, onChange]);
215	}
216	function useMutationsListener({ element, onChange }) {
217	(0, react.useEffect)(() => {
218	if (!element) return;
219	const mutationObserver = new MutationObserver(onChange);
220	mutationObserver.observe(element, {
221	childList: true,
222	subtree: true
223	});
224	return () => {
225	mutationObserver.disconnect();
226	};
227	}, [element, onChange]);
228	}
229
230	//#endregion
231	//#region packages/packages/core/editor-canvas/src/utils/grid-outline-utils.ts
232	function toGridTracks(computedStyle) {
233	return {
234	columns: parseTrackList(computedStyle.gridTemplateColumns),
235	rows: parseTrackList(computedStyle.gridTemplateRows),
236	columnGap: resolveGapPx(computedStyle.columnGap, computedStyle.width),
237	rowGap: resolveGapPx(computedStyle.rowGap, computedStyle.height),
238	padding: {
239	top: toPx(computedStyle.paddingTop),
240	right: toPx(computedStyle.paddingRight),
241	bottom: toPx(computedStyle.paddingBottom),
242	left: toPx(computedStyle.paddingLeft)
243	},
244	borderColor: computedStyle.getPropertyValue("--e-a-border-color-bold").trim()
245	};
246	}
247	function computeCellRects(tracks, width, height) {
248	const { columns, rows, columnGap, rowGap, padding } = tracks;
249	const hasColumns = columns.length > 0;
250	const hasRows = rows.length > 0;
251	if (!hasColumns && !hasRows) return [];
252	const columnSegments = hasColumns ? computeTrackSegments(columns, columnGap, padding.left) : [{
253	start: padding.left,
254	size: width - padding.left - padding.right
255	}];
256	const rowSegments = hasRows ? computeTrackSegments(rows, rowGap, padding.top) : [{
257	start: padding.top,
258	size: height - padding.top - padding.bottom
259	}];
260	const cells = [];
261	for (const row of rowSegments) for (const column of columnSegments) cells.push({
262	x: column.start,
263	y: row.start,
264	width: column.size,
265	height: row.size
266	});
267	return cells;
268	}
269	function computeGridLines(tracks, width, height) {
270	const { columns, rows, columnGap, rowGap, padding } = tracks;
271	const hasColumns = columns.length > 0;
272	const hasRows = rows.length > 0;
273	if (!hasColumns && !hasRows) return {
274	vertical: [],
275	horizontal: []
276	};
277	const columnSegments = hasColumns ? computeTrackSegments(columns, columnGap, padding.left) : [{
278	start: padding.left,
279	size: width - padding.left - padding.right
280	}];
281	const rowSegments = hasRows ? computeTrackSegments(rows, rowGap, padding.top) : [{
282	start: padding.top,
283	size: height - padding.top - padding.bottom
284	}];
285	const xs = uniqueSorted(columnSegments.flatMap((s) => [s.start, s.start + s.size]));
286	const ys = uniqueSorted(rowSegments.flatMap((s) => [s.start, s.start + s.size]));
287	const yTop = ys[0];
288	const yBottom = ys[ys.length - 1];
289	const xLeft = xs[0];
290	const xRight = xs[xs.length - 1];
291	return {
292	vertical: xs.map((x) => ({
293	x1: x,
294	y1: yTop,
295	x2: x,
296	y2: yBottom
297	})),
298	horizontal: ys.map((y) => ({
299	x1: xLeft,
300	y1: y,
301	x2: xRight,
302	y2: y
303	}))
304	};
305	}
306	function uniqueSorted(values) {
307	return Array.from(new Set(values)).sort((a, b) => a - b);
308	}
309	function computeTrackSegments(sizes, gap, offset) {
310	const segments = [];
311	let cursor = offset;
312	for (let i = 0; i < sizes.length; i++) {
313	segments.push({
314	start: cursor,
315	size: sizes[i]
316	});
317	cursor += sizes[i];
318	if (i < sizes.length - 1) cursor += gap;
319	}
320	return segments;
321	}
322	function snapToHalfPixel(value) {
323	return Math.round(value) + .5;
324	}
325	function parseTrackList(value) {
326	if (!value \|\| value === "none") return [];
327	return value.trim().split(/\s+/).map(toPx).filter((n) => n > 0);
328	}
329	function toPx(value) {
330	const parsed = parseFloat(value);
331	return Number.isFinite(parsed) ? parsed : 0;
332	}
333	function resolveGapPx(value, referenceSize) {
334	if (value.trim().endsWith("%")) {
335	const percent = parseFloat(value);
336	const reference = parseFloat(referenceSize);
337	return Number.isFinite(percent) && Number.isFinite(reference) ? percent / 100 * reference : 0;
338	}
339	return toPx(value);
340	}
341
342	//#endregion
343	//#region packages/packages/core/editor-canvas/src/hooks/use-grid-children.ts
344	function useGridChildren(element) {
345	const [signal, setSignal] = (0, react.useState)(0);
346	(0, react.useEffect)(() => {
347	if (!element) return;
348	const bump = () => setSignal((previous) => previous + 1);
349	const resizeObserver = new ResizeObserver(bump);
350	const observed = /* @__PURE__ */ new Set();
351	const syncChildren = () => {
352	for (const child of Array.from(element.children)) if (!observed.has(child)) {
353	resizeObserver.observe(child);
354	observed.add(child);
355	}
356	for (const child of observed) if (child.parentElement !== element) {
357	resizeObserver.unobserve(child);
358	observed.delete(child);
359	}
360	};
361	syncChildren();
362	const mutationObserver = new MutationObserver(() => {
363	syncChildren();
364	bump();
365	});
366	mutationObserver.observe(element, { childList: true });
367	return () => {
368	mutationObserver.disconnect();
369	resizeObserver.disconnect();
370	observed.clear();
371	};
372	}, [element]);
373	return signal;
374	}
375
376	//#endregion
377	//#region packages/packages/core/editor-canvas/src/hooks/use-grid-tracks.ts
378	var EMPTY = {
379	columns: [],
380	rows: [],
381	columnGap: 0,
382	rowGap: 0,
383	padding: {
384	top: 0,
385	right: 0,
386	bottom: 0,
387	left: 0
388	},
389	borderColor: ""
390	};
391	var DEVICE_MODE_CHANGE_EVENT = "elementor/device-mode/change";
392	function useGridTracks(element, rect) {
393	const [tracks, setTracks] = (0, react.useState)(EMPTY);
394	const trigger = (0, _elementor_editor_v1_adapters.__privateUseListenTo)([(0, _elementor_editor_v1_adapters.windowEvent)(_elementor_editor_elements.ELEMENT_STYLE_CHANGE_EVENT), (0, _elementor_editor_v1_adapters.windowEvent)(DEVICE_MODE_CHANGE_EVENT)], () => ({}));
395	const childrenTrigger = useGridChildren(element);
396	(0, react.useEffect)(() => {
397	const previewWindow = element?.ownerDocument?.defaultView;
398	if (!element \|\| !previewWindow) {
399	setTracks(EMPTY);
400	return;
401	}
402	const frame = previewWindow.requestAnimationFrame(() => {
403	setTracks(toGridTracks(previewWindow.getComputedStyle(element)));
404	});
405	return () => {
406	previewWindow.cancelAnimationFrame(frame);
407	};
408	}, [
409	element,
410	rect.width,
411	rect.height,
412	trigger,
413	childrenTrigger
414	]);
415	return tracks;
416	}
417
418	//#endregion
419	//#region packages/packages/core/editor-canvas/src/utils/find-first-empty-cell.ts
420	function findFirstEmptyCell(element, columnCount, rowCount) {
421	if (!element \|\| columnCount === 0 \|\| rowCount === 0) return null;
422	const previewWindow = element.ownerDocument?.defaultView;
423	if (!previewWindow) return null;
424	const flowsByColumn = previewWindow.getComputedStyle(element).gridAutoFlow.trim().startsWith("column");
425	const matrix = Array.from({ length: rowCount }, () => new Array(columnCount).fill(false));
426	const explicit = [];
427	const autoPlaced = [];
428	for (const child of Array.from(element.children)) {
429	if (!child.classList.contains("elementor-element")) continue;
430	const style = previewWindow.getComputedStyle(child);
431	if (style.display === "none") continue;
432	const col = resolvePlacement(style.gridColumnStart, style.gridColumnEnd);
433	const row = resolvePlacement(style.gridRowStart, style.gridRowEnd);
434	if (col.start !== null \|\| row.start !== null) explicit.push({
435	col: col.start,
436	colSpan: col.span,
437	row: row.start,
438	rowSpan: row.span
439	});
440	else autoPlaced.push({
441	colSpan: col.span,
442	rowSpan: row.span
443	});
444	}
445	for (const child of explicit) fillMatrix(matrix, child.col ?? 0, child.row ?? 0, child.colSpan, child.rowSpan);
446	for (const child of autoPlaced) {
447	const slot = findNextFreeSlot(matrix, child.colSpan, child.rowSpan, flowsByColumn);
448	if (slot) fillMatrix(matrix, slot.col, slot.row, child.colSpan, child.rowSpan);
449	}
450	return scanFirstEmpty(matrix, flowsByColumn);
451	}
452	function resolvePlacement(startRaw, endRaw) {
453	const start = parseLineValue(startRaw);
454	const end = parseLineValue(endRaw);
455	if (typeof start === "number") {
456	const zeroIndexedStart = start - 1;
457	if (typeof end === "number") return {
458	start: zeroIndexedStart,
459	span: Math.max(1, end - start)
460	};
461	if (isSpan(end)) return {
462	start: zeroIndexedStart,
463	span: end.n
464	};
465	return {
466	start: zeroIndexedStart,
467	span: 1
468	};
469	}
470	if (isSpan(start)) {
471	if (typeof end === "number") {
472	const zeroIndexedStart = end - 1 - start.n;
473	return {
474	start: zeroIndexedStart >= 0 ? zeroIndexedStart : null,
475	span: start.n
476	};
477	}
478	return {
479	start: null,
480	span: start.n
481	};
482	}
483	if (typeof end === "number") {
484	const zeroIndexedStart = end - 2;
485	return {
486	start: zeroIndexedStart >= 0 ? zeroIndexedStart : null,
487	span: 1
488	};
489	}
490	if (isSpan(end)) return {
491	start: null,
492	span: end.n
493	};
494	return {
495	start: null,
496	span: 1
497	};
498	}
499	function parseLineValue(raw) {
500	const trimmed = raw.trim();
501	if (trimmed === "" \|\| trimmed === "auto") return "auto";
502	const spanMatch = trimmed.match(/^span\s+(\d+)$/);
503	if (spanMatch) {
504	const n = parseInt(spanMatch[1], 10);
505	return {
506	kind: "span",
507	n: Math.max(1, n)
508	};
509	}
510	const parsed = parseInt(trimmed, 10);
511	if (Number.isFinite(parsed) && parsed > 0) return parsed;
512	return "auto";
513	}
514	function isSpan(value) {
515	return typeof value === "object" && value !== null && "kind" in value && value.kind === "span";
516	}
517	function fillMatrix(matrix, col, row, colSpan, rowSpan) {
518	const rows = matrix.length;
519	const cols = rows > 0 ? matrix[0].length : 0;
520	const startRow = Math.max(0, row);
521	const startCol = Math.max(0, col);
522	const endRow = Math.min(rows, row + rowSpan);
523	const endCol = Math.min(cols, col + colSpan);
524	for (let r = startRow; r < endRow; r++) for (let c = startCol; c < endCol; c++) matrix[r][c] = true;
525	}
526	function findNextFreeSlot(matrix, colSpan, rowSpan, flowsByColumn) {
527	const rows = matrix.length;
528	const maxCol = (rows > 0 ? matrix[0].length : 0) - colSpan;
529	const maxRow = rows - rowSpan;
530	if (maxCol < 0 \|\| maxRow < 0) return null;
531	if (flowsByColumn) {
532	for (let col = 0; col <= maxCol; col++) for (let row = 0; row <= maxRow; row++) if (canFit(matrix, col, row, colSpan, rowSpan)) return {
533	row,
534	col
535	};
536	} else for (let row = 0; row <= maxRow; row++) for (let col = 0; col <= maxCol; col++) if (canFit(matrix, col, row, colSpan, rowSpan)) return {
537	row,
538	col
539	};
540	return null;
541	}
542	function canFit(matrix, col, row, colSpan, rowSpan) {
543	for (let r = row; r < row + rowSpan; r++) for (let c = col; c < col + colSpan; c++) if (matrix[r][c]) return false;
544	return true;
545	}
546	function scanFirstEmpty(matrix, flowsByColumn) {
547	const rows = matrix.length;
548	const cols = rows > 0 ? matrix[0].length : 0;
549	if (flowsByColumn) {
550	for (let col = 0; col < cols; col++) for (let row = 0; row < rows; row++) if (!matrix[row][col]) return {
551	row,
552	col
553	};
554	} else for (let row = 0; row < rows; row++) for (let col = 0; col < cols; col++) if (!matrix[row][col]) return {
555	row,
556	col
557	};
558	return null;
559	}
560
561	//#endregion
562	//#region packages/packages/core/editor-canvas/src/components/grid-outline/grid-empty-cell-positioner.tsx
563	var CSS_VAR_ROW = "--e-grid-empty-cell-row";
564	var CSS_VAR_COL = "--e-grid-empty-cell-col";
565	var CSS_VAR_VISIBILITY = "--e-grid-empty-cell-visibility";
566	var clearGridEmptyCellStyles = (target) => {
567	target.style.removeProperty(CSS_VAR_ROW);
568	target.style.removeProperty(CSS_VAR_COL);
569	target.style.removeProperty(CSS_VAR_VISIBILITY);
570	};
571	var GridEmptyCellPositioner = ({ element }) => {
572	const tracks = useGridTracks(element, useElementRect(element));
573	(0, react.useEffect)(() => {
574	if (!element) return;
575	const firstEmpty = findFirstEmptyCell(element, tracks.columns.length, tracks.rows.length);
576	if (!firstEmpty) {
577	element.style.removeProperty(CSS_VAR_ROW);
578	element.style.removeProperty(CSS_VAR_COL);
579	element.style.setProperty(CSS_VAR_VISIBILITY, "hidden");
580	return () => clearGridEmptyCellStyles(element);
581	}
582	element.style.setProperty(CSS_VAR_ROW, String(firstEmpty.row + 1));
583	element.style.setProperty(CSS_VAR_COL, String(firstEmpty.col + 1));
584	element.style.setProperty(CSS_VAR_VISIBILITY, "visible");
585	return () => {
586	clearGridEmptyCellStyles(element);
587	};
588	}, [element, tracks]);
589	return null;
590	};
591
592	//#endregion
593	//#region node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
594	function hasWindow() {
595	return typeof window !== "undefined";
596	}
597	function getNodeName(node) {
598	if (isNode(node)) return (node.nodeName \|\| "").toLowerCase();
599	return "#document";
600	}
601	function getWindow(node) {
602	var _node$ownerDocument;
603	return (node == null \|\| (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) \|\| window;
604	}
605	function getDocumentElement(node) {
606	var _ref;
607	return (_ref = (isNode(node) ? node.ownerDocument : node.document) \|\| window.document) == null ? void 0 : _ref.documentElement;
608	}
609	function isNode(value) {
610	if (!hasWindow()) return false;
611	return value instanceof Node \|\| value instanceof getWindow(value).Node;
612	}
613	function isElement(value) {
614	if (!hasWindow()) return false;
615	return value instanceof Element \|\| value instanceof getWindow(value).Element;
616	}
617	function isHTMLElement(value) {
618	if (!hasWindow()) return false;
619	return value instanceof HTMLElement \|\| value instanceof getWindow(value).HTMLElement;
620	}
621	function isShadowRoot(value) {
622	if (!hasWindow() \|\| typeof ShadowRoot === "undefined") return false;
623	return value instanceof ShadowRoot \|\| value instanceof getWindow(value).ShadowRoot;
624	}
625	function isOverflowElement(element) {
626	const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
627	return /auto\|scroll\|overlay\|hidden\|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
628	}
629	function isTableElement(element) {
630	return /^(table\|td\|th)$/.test(getNodeName(element));
631	}
632	function isTopLayer(element) {
633	try {
634	if (element.matches(":popover-open")) return true;
635	} catch (_e) {}
636	try {
637	return element.matches(":modal");
638	} catch (_e) {
639	return false;
640	}
641	}
642	var willChangeRe = /transform\|translate\|scale\|rotate\|perspective\|filter/;
643	var containRe = /paint\|layout\|strict\|content/;
644	var isNotNone = (value) => !!value && value !== "none";
645	var isWebKitValue;
646	function isContainingBlock(elementOrCss) {
647	const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
648	return isNotNone(css.transform) \|\| isNotNone(css.translate) \|\| isNotNone(css.scale) \|\| isNotNone(css.rotate) \|\| isNotNone(css.perspective) \|\| !isWebKit() && (isNotNone(css.backdropFilter) \|\| isNotNone(css.filter)) \|\| willChangeRe.test(css.willChange \|\| "") \|\| containRe.test(css.contain \|\| "");
649	}
650	function getContainingBlock(element) {
651	let currentNode = getParentNode(element);
652	while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
653	if (isContainingBlock(currentNode)) return currentNode;
654	else if (isTopLayer(currentNode)) return null;
655	currentNode = getParentNode(currentNode);
656	}
657	return null;
658	}
659	function isWebKit() {
660	if (isWebKitValue == null) isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
661	return isWebKitValue;
662	}
663	function isLastTraversableNode(node) {
664	return /^(html\|body\|#document)$/.test(getNodeName(node));
665	}
666	function getComputedStyle$1(element) {
667	return getWindow(element).getComputedStyle(element);
668	}
669	__name(getComputedStyle$1, "getComputedStyle");
670	function getNodeScroll(element) {
671	if (isElement(element)) return {
672	scrollLeft: element.scrollLeft,
673	scrollTop: element.scrollTop
674	};
675	return {
676	scrollLeft: element.scrollX,
677	scrollTop: element.scrollY
678	};
679	}
680	function getParentNode(node) {
681	if (getNodeName(node) === "html") return node;
682	const result = node.assignedSlot \|\| node.parentNode \|\| isShadowRoot(node) && node.host \|\| getDocumentElement(node);
683	return isShadowRoot(result) ? result.host : result;
684	}
685	function getNearestOverflowAncestor(node) {
686	const parentNode = getParentNode(node);
687	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
688	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
689	return getNearestOverflowAncestor(parentNode);
690	}
691	function getOverflowAncestors(node, list, traverseIframes) {
692	var _node$ownerDocument2;
693	if (list === void 0) list = [];
694	if (traverseIframes === void 0) traverseIframes = true;
695	const scrollableAncestor = getNearestOverflowAncestor(node);
696	const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
697	const win = getWindow(scrollableAncestor);
698	if (isBody) {
699	const frameElement = getFrameElement(win);
700	return list.concat(win, win.visualViewport \|\| [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
701	} else return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
702	}
703	function getFrameElement(win) {
704	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
705	}
706
707	//#endregion
708	//#region node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
709	var min = Math.min;
710	var max = Math.max;
711	var round = Math.round;
712	var floor = Math.floor;
713	var createCoords = (v) => ({
714	x: v,
715	y: v
716	});
717	var oppositeSideMap = {
718	left: "right",
719	right: "left",
720	bottom: "top",
721	top: "bottom"
722	};
723	function evaluate(value, param) {
724	return typeof value === "function" ? value(param) : value;
725	}
726	function getSide(placement) {
727	return placement.split("-")[0];
728	}
729	function getAlignment(placement) {
730	return placement.split("-")[1];
731	}
732	function getOppositeAxis(axis) {
733	return axis === "x" ? "y" : "x";
734	}
735	function getAxisLength(axis) {
736	return axis === "y" ? "height" : "width";
737	}
738	function getSideAxis(placement) {
739	const firstChar = placement[0];
740	return firstChar === "t" \|\| firstChar === "b" ? "y" : "x";
741	}
742	function getAlignmentAxis(placement) {
743	return getOppositeAxis(getSideAxis(placement));
744	}
745	function getAlignmentSides(placement, rects, rtl) {
746	if (rtl === void 0) rtl = false;
747	const alignment = getAlignment(placement);
748	const alignmentAxis = getAlignmentAxis(placement);
749	const length = getAxisLength(alignmentAxis);
750	let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
751	if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
752	return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
753	}
754	function getExpandedPlacements(placement) {
755	const oppositePlacement = getOppositePlacement(placement);
756	return [
757	getOppositeAlignmentPlacement(placement),
758	oppositePlacement,
759	getOppositeAlignmentPlacement(oppositePlacement)
760	];
761	}
762	function getOppositeAlignmentPlacement(placement) {
763	return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
764	}
765	var lrPlacement = ["left", "right"];
766	var rlPlacement = ["right", "left"];
767	var tbPlacement = ["top", "bottom"];
768	var btPlacement = ["bottom", "top"];
769	function getSideList(side, isStart, rtl) {
770	switch (side) {
771	case "top":
772	case "bottom":
773	if (rtl) return isStart ? rlPlacement : lrPlacement;
774	return isStart ? lrPlacement : rlPlacement;
775	case "left":
776	case "right": return isStart ? tbPlacement : btPlacement;
777	default: return [];
778	}
779	}
780	function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
781	const alignment = getAlignment(placement);
782	let list = getSideList(getSide(placement), direction === "start", rtl);
783	if (alignment) {
784	list = list.map((side) => side + "-" + alignment);
785	if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
786	}
787	return list;
788	}
789	function getOppositePlacement(placement) {
790	const side = getSide(placement);
791	return oppositeSideMap[side] + placement.slice(side.length);
792	}
793	function expandPaddingObject(padding) {
794	return {
795	top: 0,
796	right: 0,
797	bottom: 0,
798	left: 0,
799	...padding
800	};
801	}
802	function getPaddingObject(padding) {
803	return typeof padding !== "number" ? expandPaddingObject(padding) : {
804	top: padding,
805	right: padding,
806	bottom: padding,
807	left: padding
808	};
809	}
810	function rectToClientRect(rect) {
811	const { x, y, width, height } = rect;
812	return {
813	width,
814	height,
815	top: y,
816	left: x,
817	right: x + width,
818	bottom: y + height,
819	x,
820	y
821	};
822	}
823
824	//#endregion
825	//#region node_modules/tabbable/dist/index.esm.js
826	/*!
827	* tabbable 6.4.0
828	* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
829	*/
830	var candidateSelectors = [
831	"input:not([inert]):not([inert] *)",
832	"select:not([inert]):not([inert] *)",
833	"textarea:not([inert]):not([inert] *)",
834	"a[href]:not([inert]):not([inert] *)",
835	"button:not([inert]):not([inert] *)",
836	"[tabindex]:not(slot):not([inert]):not([inert] *)",
837	"audio[controls]:not([inert]):not([inert] *)",
838	"video[controls]:not([inert]):not([inert] *)",
839	"[contenteditable]:not([contenteditable=\"false\"]):not([inert]):not([inert] *)",
840	"details>summary:first-of-type:not([inert]):not([inert] *)",
841	"details:not([inert]):not([inert] *)"
842	];
843	var candidateSelector = /* #__PURE__ */ candidateSelectors.join(",");
844	var NoElement = typeof Element === "undefined";
845	var matches = NoElement ? function() {} : Element.prototype.matches \|\| Element.prototype.msMatchesSelector \|\| Element.prototype.webkitMatchesSelector;
846	var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
847	var _element$getRootNode;
848	return element === null \|\| element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null \|\| _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
849	} : function(element) {
850	return element === null \|\| element === void 0 ? void 0 : element.ownerDocument;
851	};
852	/**
853	* Determines if a node is inert or in an inert ancestor.
854	* @param {Node} [node]
855	* @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
856	* see if any of them are inert. If false, only `node` itself is considered.
857	* @returns {boolean} True if inert itself or by way of being in an inert ancestor.
858	* False if `node` is falsy.
859	*/
860	var _isInert = function isInert(node, lookUp) {
861	var _node$getAttribute;
862	if (lookUp === void 0) lookUp = true;
863	var inertAtt = node === null \|\| node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null \|\| _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
864	return inertAtt === "" \|\| inertAtt === "true" \|\| lookUp && node && (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
865	};
866	/**
867	* Determines if a node's content is editable.
868	* @param {Element} [node]
869	* @returns True if it's content-editable; false if it's not or `node` is falsy.
870	*/
871	var isContentEditable = function isContentEditable(node) {
872	var _node$getAttribute2;
873	var attValue = node === null \|\| node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null \|\| _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
874	return attValue === "" \|\| attValue === "true";
875	};
876	/**
877	* @param {Element} el container to check in
878	* @param {boolean} includeContainer add container to check
879	* @param {(node: Element) => boolean} filter filter candidates
880	* @returns {Element[]}
881	*/
882	var getCandidates = function getCandidates(el, includeContainer, filter) {
883	if (_isInert(el)) return [];
884	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
885	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
886	candidates = candidates.filter(filter);
887	return candidates;
888	};
889	/**
890	* @callback GetShadowRoot
891	* @param {Element} element to check for shadow root
892	* @returns {ShadowRoot\|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
893	*/
894	/**
895	* @callback ShadowRootFilter
896	* @param {Element} shadowHostNode the element which contains shadow content
897	* @returns {boolean} true if a shadow root could potentially contain valid candidates.
898	*/
899	/**
900	* @typedef {Object} CandidateScope
901	* @property {Element} scopeParent contains inner candidates
902	* @property {Element[]} candidates list of candidates found in the scope parent
903	*/
904	/**
905	* @typedef {Object} IterativeOptions
906	* @property {GetShadowRoot\|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
907	* if a function, implies shadow support is enabled and either returns the shadow root of an element
908	* or a boolean stating if it has an undisclosed shadow root
909	* @property {(node: Element) => boolean} filter filter candidates
910	* @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list
911	* @property {ShadowRootFilter} shadowRootFilter filter shadow roots;
912	*/
913	/**
914	* @param {Element[]} elements list of element containers to match candidates from
915	* @param {boolean} includeContainer add container list to check
916	* @param {IterativeOptions} options
917	* @returns {Array.<Element\|CandidateScope>}
918	*/
919	var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
920	var candidates = [];
921	var elementsToCheck = Array.from(elements);
922	while (elementsToCheck.length) {
923	var element = elementsToCheck.shift();
924	if (_isInert(element, false)) continue;
925	if (element.tagName === "SLOT") {
926	var assigned = element.assignedElements();
927	var nestedCandidates = _getCandidatesIteratively(assigned.length ? assigned : element.children, true, options);
928	if (options.flatten) candidates.push.apply(candidates, nestedCandidates);
929	else candidates.push({
930	scopeParent: element,
931	candidates: nestedCandidates
932	});
933	} else {
934	if (matches.call(element, candidateSelector) && options.filter(element) && (includeContainer \|\| !elements.includes(element))) candidates.push(element);
935	var shadowRoot = element.shadowRoot \|\| typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
936	var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter \|\| options.shadowRootFilter(element));
937	if (shadowRoot && validShadowRoot) {
938	var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
939	if (options.flatten) candidates.push.apply(candidates, _nestedCandidates);
940	else candidates.push({
941	scopeParent: element,
942	candidates: _nestedCandidates
943	});
944	} else elementsToCheck.unshift.apply(elementsToCheck, element.children);
945	}
946	}
947	return candidates;
948	};
949	/**
950	* @private
951	* Determines if the node has an explicitly specified `tabindex` attribute.
952	* @param {HTMLElement} node
953	* @returns {boolean} True if so; false if not.
954	*/
955	var hasTabIndex = function hasTabIndex(node) {
956	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
957	};
958	/**
959	* Determine the tab index of a given node.
960	* @param {HTMLElement} node
961	* @returns {number} Tab order (negative, 0, or positive number).
962	* @throws {Error} If `node` is falsy.
963	*/
964	var getTabIndex = function getTabIndex(node) {
965	if (!node) throw new Error("No node provided");
966	if (node.tabIndex < 0) {
967	if ((/^(AUDIO\|VIDEO\|DETAILS)$/.test(node.tagName) \|\| isContentEditable(node)) && !hasTabIndex(node)) return 0;
968	}
969	return node.tabIndex;
970	};
971	/**
972	* Determine the tab index of a given node __for sort order purposes__.
973	* @param {HTMLElement} node
974	* @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,
975	* has tabIndex -1, but needs to be sorted by document order in order for its content to be
976	* inserted into the correct sort position.
977	* @returns {number} Tab order (negative, 0, or positive number).
978	*/
979	var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {
980	var tabIndex = getTabIndex(node);
981	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
982	return tabIndex;
983	};
984	var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
985	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
986	};
987	var isInput = function isInput(node) {
988	return node.tagName === "INPUT";
989	};
990	var isHiddenInput = function isHiddenInput(node) {
991	return isInput(node) && node.type === "hidden";
992	};
993	var isDetailsWithSummary = function isDetailsWithSummary(node) {
994	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
995	return child.tagName === "SUMMARY";
996	});
997	};
998	var getCheckedRadio = function getCheckedRadio(nodes, form) {
999	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
1000	};
1001	var isTabbableRadio = function isTabbableRadio(node) {
1002	if (!node.name) return true;
1003	var radioScope = node.form \|\| getRootNode(node);
1004	var queryRadios = function queryRadios(name) {
1005	return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
1006	};
1007	var radioSet;
1008	if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") radioSet = queryRadios(window.CSS.escape(node.name));
1009	else try {
1010	radioSet = queryRadios(node.name);
1011	} catch (err) {
1012	console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
1013	return false;
1014	}
1015	var checked = getCheckedRadio(radioSet, node.form);
1016	return !checked \|\| checked === node;
1017	};
1018	var isRadio = function isRadio(node) {
1019	return isInput(node) && node.type === "radio";
1020	};
1021	var isNonTabbableRadio = function isNonTabbableRadio(node) {
1022	return isRadio(node) && !isTabbableRadio(node);
1023	};
1024	var isNodeAttached = function isNodeAttached(node) {
1025	var _nodeRoot;
1026	var nodeRoot = node && getRootNode(node);
1027	var nodeRootHost = (_nodeRoot = nodeRoot) === null \|\| _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
1028	var attached = false;
1029	if (nodeRoot && nodeRoot !== node) {
1030	var _nodeRootHost;
1031	var _nodeRootHost$ownerDo;
1032	var _node$ownerDocument;
1033	attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) \|\| node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
1034	while (!attached && nodeRootHost) {
1035	var _nodeRoot2;
1036	var _nodeRootHost2;
1037	var _nodeRootHost2$ownerD;
1038	nodeRoot = getRootNode(nodeRootHost);
1039	nodeRootHost = (_nodeRoot2 = nodeRoot) === null \|\| _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
1040	attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
1041	}
1042	}
1043	return attached;
1044	};
1045	var isZeroArea = function isZeroArea(node) {
1046	var _node$getBoundingClie = node.getBoundingClientRect();
1047	var width = _node$getBoundingClie.width;
1048	var height = _node$getBoundingClie.height;
1049	return width === 0 && height === 0;
1050	};
1051	var isHidden = function isHidden(node, _ref) {
1052	var displayCheck = _ref.displayCheck;
1053	var getShadowRoot = _ref.getShadowRoot;
1054	if (displayCheck === "full-native") {
1055	if ("checkVisibility" in node) return !node.checkVisibility({
1056	checkOpacity: false,
1057	opacityProperty: false,
1058	contentVisibilityAuto: true,
1059	visibilityProperty: true,
1060	checkVisibilityCSS: true
1061	});
1062	}
1063	if (getComputedStyle(node).visibility === "hidden") return true;
1064	var nodeUnderDetails = matches.call(node, "details>summary:first-of-type") ? node.parentElement : node;
1065	if (matches.call(nodeUnderDetails, "details:not([open]) *")) return true;
1066	if (!displayCheck \|\| displayCheck === "full" \|\| displayCheck === "full-native" \|\| displayCheck === "legacy-full") {
1067	if (typeof getShadowRoot === "function") {
1068	var originalNode = node;
1069	while (node) {
1070	var parentElement = node.parentElement;
1071	var rootNode = getRootNode(node);
1072	if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) return isZeroArea(node);
1073	else if (node.assignedSlot) node = node.assignedSlot;
1074	else if (!parentElement && rootNode !== node.ownerDocument) node = rootNode.host;
1075	else node = parentElement;
1076	}
1077	node = originalNode;
1078	}
1079	if (isNodeAttached(node)) return !node.getClientRects().length;
1080	if (displayCheck !== "legacy-full") return true;
1081	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
1082	return false;
1083	};
1084	var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
1085	if (/^(INPUT\|BUTTON\|SELECT\|TEXTAREA)$/.test(node.tagName)) {
1086	var parentNode = node.parentElement;
1087	while (parentNode) {
1088	if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
1089	for (var i = 0; i < parentNode.children.length; i++) {
1090	var child = parentNode.children.item(i);
1091	if (child.tagName === "LEGEND") return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
1092	}
1093	return true;
1094	}
1095	parentNode = parentNode.parentElement;
1096	}
1097	}
1098	return false;
1099	};
1100	var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
1101	if (node.disabled \|\| isHiddenInput(node) \|\| isHidden(node, options) \|\| isDetailsWithSummary(node) \|\| isDisabledFromFieldset(node)) return false;
1102	return true;
1103	};
1104	var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
1105	if (isNonTabbableRadio(node) \|\| getTabIndex(node) < 0 \|\| !isNodeMatchingSelectorFocusable(options, node)) return false;
1106	return true;
1107	};
1108	var isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {
1109	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
1110	if (isNaN(tabIndex) \|\| tabIndex >= 0) return true;
1111	return false;
1112	};
1113	/**
1114	* @param {Array.<Element\|CandidateScope>} candidates
1115	* @returns Element[]
1116	*/
1117	var _sortByOrder = function sortByOrder(candidates) {
1118	var regularTabbables = [];
1119	var orderedTabbables = [];
1120	candidates.forEach(function(item, i) {
1121	var isScope = !!item.scopeParent;
1122	var element = isScope ? item.scopeParent : item;
1123	var candidateTabindex = getSortOrderTabIndex(element, isScope);
1124	var elements = isScope ? _sortByOrder(item.candidates) : element;
1125	if (candidateTabindex === 0) isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
1126	else orderedTabbables.push({
1127	documentOrder: i,
1128	tabIndex: candidateTabindex,
1129	item,
1130	isScope,
1131	content: elements
1132	});
1133	});
1134	return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
1135	sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
1136	return acc;
1137	}, []).concat(regularTabbables);
1138	};
1139	var tabbable = function tabbable(container, options) {
1140	options = options \|\| {};
1141	var candidates;
1142	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
1143	filter: isNodeMatchingSelectorTabbable.bind(null, options),
1144	flatten: false,
1145	getShadowRoot: options.getShadowRoot,
1146	shadowRootFilter: isShadowRootTabbable
1147	});
1148	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
1149	return _sortByOrder(candidates);
1150	};
1151
1152	//#endregion
1153	//#region node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs
1154	function isSafari() {
1155	return /apple/i.test(navigator.vendor);
1156	}
1157	function activeElement(doc) {
1158	let activeElement = doc.activeElement;
1159	while (((_activeElement = activeElement) == null \|\| (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {
1160	var _activeElement;
1161	activeElement = activeElement.shadowRoot.activeElement;
1162	}
1163	return activeElement;
1164	}
1165	function contains(parent, child) {
1166	if (!parent \|\| !child) return false;
1167	const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
1168	if (parent.contains(child)) return true;
1169	if (rootNode && isShadowRoot(rootNode)) {
1170	let next = child;
1171	while (next) {
1172	if (parent === next) return true;
1173	next = next.parentNode \|\| next.host;
1174	}
1175	}
1176	return false;
1177	}
1178	function getDocument(node) {
1179	return (node == null ? void 0 : node.ownerDocument) \|\| document;
1180	}
1181	function isMouseLikePointerType(pointerType, strict) {
1182	const values = ["mouse", "pen"];
1183	if (!strict) values.push("", void 0);
1184	return values.includes(pointerType);
1185	}
1186	var index$1 = typeof document !== "undefined" ? react$1.useLayoutEffect : function noop() {};
1187	var SafeReact$1 = { ...react$1 };
1188	function useLatestRef$1(value) {
1189	const ref = react$1.useRef(value);
1190	index$1(() => {
1191	ref.current = value;
1192	});
1193	return ref;
1194	}
1195	__name(useLatestRef$1, "useLatestRef");
1196	var useSafeInsertionEffect = SafeReact$1.useInsertionEffect \|\| ((fn) => fn());
1197	function useEffectEvent(callback) {
1198	const ref = react$1.useRef(() => {
1199	throw new Error("Cannot call an event handler while rendering.");
1200	});
1201	useSafeInsertionEffect(() => {
1202	ref.current = callback;
1203	});
1204	return react$1.useCallback(function() {
1205	for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
1206	return ref.current == null ? void 0 : ref.current(...args);
1207	}, []);
1208	}
1209	var getTabbableOptions = () => ({
1210	getShadowRoot: true,
1211	displayCheck: typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
1212	});
1213	function getTabbableIn(container, dir) {
1214	const list = tabbable(container, getTabbableOptions());
1215	const len = list.length;
1216	if (len === 0) return;
1217	const active = activeElement(getDocument(container));
1218	const index = list.indexOf(active);
1219	return list[index === -1 ? dir === 1 ? 0 : len - 1 : index + dir];
1220	}
1221	function getNextTabbable(referenceElement) {
1222	return getTabbableIn(getDocument(referenceElement).body, 1) \|\| referenceElement;
1223	}
1224	function getPreviousTabbable(referenceElement) {
1225	return getTabbableIn(getDocument(referenceElement).body, -1) \|\| referenceElement;
1226	}
1227	function isOutsideEvent(event, container) {
1228	const containerElement = container \|\| event.currentTarget;
1229	const relatedTarget = event.relatedTarget;
1230	return !relatedTarget \|\| !contains(containerElement, relatedTarget);
1231	}
1232	function disableFocusInside(container) {
1233	tabbable(container, getTabbableOptions()).forEach((element) => {
1234	element.dataset.tabindex = element.getAttribute("tabindex") \|\| "";
1235	element.setAttribute("tabindex", "-1");
1236	});
1237	}
1238	function enableFocusInside(container) {
1239	container.querySelectorAll("[data-tabindex]").forEach((element) => {
1240	const tabindex = element.dataset.tabindex;
1241	delete element.dataset.tabindex;
1242	if (tabindex) element.setAttribute("tabindex", tabindex);
1243	else element.removeAttribute("tabindex");
1244	});
1245	}
1246
1247	//#endregion
1248	//#region node_modules/react/cjs/react-jsx-runtime.development.js
1249	/**
1250	* @license React
1251	* react-jsx-runtime.development.js
1252	*
1253	* Copyright (c) Facebook, Inc. and its affiliates.
1254	*
1255	* This source code is licensed under the MIT license found in the
1256	* LICENSE file in the root directory of this source tree.
1257	*/
1258	var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((exports) => {
1259	(function() {
1260	"use strict";
1261	var React = (globalThis.React);
1262	var REACT_ELEMENT_TYPE = Symbol.for("react.element");
1263	var REACT_PORTAL_TYPE = Symbol.for("react.portal");
1264	var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
1265	var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
1266	var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
1267	var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
1268	var REACT_CONTEXT_TYPE = Symbol.for("react.context");
1269	var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
1270	var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
1271	var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
1272	var REACT_MEMO_TYPE = Symbol.for("react.memo");
1273	var REACT_LAZY_TYPE = Symbol.for("react.lazy");
1274	var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
1275	var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
1276	var FAUX_ITERATOR_SYMBOL = "@@iterator";
1277	function getIteratorFn(maybeIterable) {
1278	if (maybeIterable === null \|\| typeof maybeIterable !== "object") return null;
1279	var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] \|\| maybeIterable[FAUX_ITERATOR_SYMBOL];
1280	if (typeof maybeIterator === "function") return maybeIterator;
1281	return null;
1282	}
1283	var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
1284	function error(format) {
1285	for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
1286	printWarning("error", format, args);
1287	}
1288	function printWarning(level, format, args) {
1289	var stack = ReactSharedInternals.ReactDebugCurrentFrame.getStackAddendum();
1290	if (stack !== "") {
1291	format += "%s";
1292	args = args.concat([stack]);
1293	}
1294	var argsWithFormat = args.map(function(item) {
1295	return String(item);
1296	});
1297	argsWithFormat.unshift("Warning: " + format);
1298	Function.prototype.apply.call(console[level], console, argsWithFormat);
1299	}
1300	var enableScopeAPI = false;
1301	var enableCacheElement = false;
1302	var enableTransitionTracing = false;
1303	var enableLegacyHidden = false;
1304	var enableDebugTracing = false;
1305	var REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
1306	function isValidElementType(type) {
1307	if (typeof type === "string" \|\| typeof type === "function") return true;
1308	if (type === REACT_FRAGMENT_TYPE \|\| type === REACT_PROFILER_TYPE \|\| enableDebugTracing \|\| type === REACT_STRICT_MODE_TYPE \|\| type === REACT_SUSPENSE_TYPE \|\| type === REACT_SUSPENSE_LIST_TYPE \|\| enableLegacyHidden \|\| type === REACT_OFFSCREEN_TYPE \|\| enableScopeAPI \|\| enableCacheElement \|\| enableTransitionTracing) return true;
1309	if (typeof type === "object" && type !== null) {
1310	if (type.$$typeof === REACT_LAZY_TYPE \|\| type.$$typeof === REACT_MEMO_TYPE \|\| type.$$typeof === REACT_PROVIDER_TYPE \|\| type.$$typeof === REACT_CONTEXT_TYPE \|\| type.$$typeof === REACT_FORWARD_REF_TYPE \|\| type.$$typeof === REACT_MODULE_REFERENCE \|\| type.getModuleId !== void 0) return true;
1311	}
1312	return false;
1313	}
1314	function getWrappedName(outerType, innerType, wrapperName) {
1315	var displayName = outerType.displayName;
1316	if (displayName) return displayName;
1317	var functionName = innerType.displayName \|\| innerType.name \|\| "";
1318	return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
1319	}
1320	function getContextName(type) {
1321	return type.displayName \|\| "Context";
1322	}
1323	function getComponentNameFromType(type) {
1324	if (type == null) return null;
1325	if (typeof type.tag === "number") error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
1326	if (typeof type === "function") return type.displayName \|\| type.name \|\| null;
1327	if (typeof type === "string") return type;
1328	switch (type) {
1329	case REACT_FRAGMENT_TYPE: return "Fragment";
1330	case REACT_PORTAL_TYPE: return "Portal";
1331	case REACT_PROFILER_TYPE: return "Profiler";
1332	case REACT_STRICT_MODE_TYPE: return "StrictMode";
1333	case REACT_SUSPENSE_TYPE: return "Suspense";
1334	case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
1335	}
1336	if (typeof type === "object") switch (type.$$typeof) {
1337	case REACT_CONTEXT_TYPE: return getContextName(type) + ".Consumer";
1338	case REACT_PROVIDER_TYPE: return getContextName(type._context) + ".Provider";
1339	case REACT_FORWARD_REF_TYPE: return getWrappedName(type, type.render, "ForwardRef");
1340	case REACT_MEMO_TYPE:
1341	var outerName = type.displayName \|\| null;
1342	if (outerName !== null) return outerName;
1343	return getComponentNameFromType(type.type) \|\| "Memo";
1344	case REACT_LAZY_TYPE:
1345	var lazyComponent = type;
1346	var payload = lazyComponent._payload;
1347	var init = lazyComponent._init;
1348	try {
1349	return getComponentNameFromType(init(payload));
1350	} catch (x) {
1351	return null;
1352	}
1353	}
1354	return null;
1355	}
1356	var assign = Object.assign;
1357	var disabledDepth = 0;
1358	var prevLog;
1359	var prevInfo;
1360	var prevWarn;
1361	var prevError;
1362	var prevGroup;
1363	var prevGroupCollapsed;
1364	var prevGroupEnd;
1365	function disabledLog() {}
1366	disabledLog.__reactDisabledLog = true;
1367	function disableLogs() {
1368	if (disabledDepth === 0) {
1369	prevLog = console.log;
1370	prevInfo = console.info;
1371	prevWarn = console.warn;
1372	prevError = console.error;
1373	prevGroup = console.group;
1374	prevGroupCollapsed = console.groupCollapsed;
1375	prevGroupEnd = console.groupEnd;
1376	var props = {
1377	configurable: true,
1378	enumerable: true,
1379	value: disabledLog,
1380	writable: true
1381	};
1382	Object.defineProperties(console, {
1383	info: props,
1384	log: props,
1385	warn: props,
1386	error: props,
1387	group: props,
1388	groupCollapsed: props,
1389	groupEnd: props
1390	});
1391	}
1392	disabledDepth++;
1393	}
1394	function reenableLogs() {
1395	disabledDepth--;
1396	if (disabledDepth === 0) {
1397	var props = {
1398	configurable: true,
1399	enumerable: true,
1400	writable: true
1401	};
1402	Object.defineProperties(console, {
1403	log: assign({}, props, { value: prevLog }),
1404	info: assign({}, props, { value: prevInfo }),
1405	warn: assign({}, props, { value: prevWarn }),
1406	error: assign({}, props, { value: prevError }),
1407	group: assign({}, props, { value: prevGroup }),
1408	groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
1409	groupEnd: assign({}, props, { value: prevGroupEnd })
1410	});
1411	}
1412	if (disabledDepth < 0) error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
1413	}
1414	var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
1415	var prefix;
1416	function describeBuiltInComponentFrame(name, source, ownerFn) {
1417	if (prefix === void 0) try {
1418	throw Error();
1419	} catch (x) {
1420	var match = x.stack.trim().match(/\n( *(at )?)/);
1421	prefix = match && match[1] \|\| "";
1422	}
1423	return "\n" + prefix + name;
1424	}
1425	var reentry = false;
1426	var componentFrameCache = new (typeof WeakMap === "function" ? WeakMap : Map)();
1427	function describeNativeComponentFrame(fn, construct) {
1428	if (!fn \|\| reentry) return "";
1429	var frame = componentFrameCache.get(fn);
1430	if (frame !== void 0) return frame;
1431	var control;
1432	reentry = true;
1433	var previousPrepareStackTrace = Error.prepareStackTrace;
1434	Error.prepareStackTrace = void 0;
1435	var previousDispatcher = ReactCurrentDispatcher.current;
1436	ReactCurrentDispatcher.current = null;
1437	disableLogs();
1438	try {
1439	if (construct) {
1440	var Fake = function() {
1441	throw Error();
1442	};
1443	Object.defineProperty(Fake.prototype, "props", { set: function() {
1444	throw Error();
1445	} });
1446	if (typeof Reflect === "object" && Reflect.construct) {
1447	try {
1448	Reflect.construct(Fake, []);
1449	} catch (x) {
1450	control = x;
1451	}
1452	Reflect.construct(fn, [], Fake);
1453	} else {
1454	try {
1455	Fake.call();
1456	} catch (x) {
1457	control = x;
1458	}
1459	fn.call(Fake.prototype);
1460	}
1461	} else {
1462	try {
1463	throw Error();
1464	} catch (x) {
1465	control = x;
1466	}
1467	fn();
1468	}
1469	} catch (sample) {
1470	if (sample && control && typeof sample.stack === "string") {
1471	var sampleLines = sample.stack.split("\n");
1472	var controlLines = control.stack.split("\n");
1473	var s = sampleLines.length - 1;
1474	var c = controlLines.length - 1;
1475	while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) c--;
1476	for (; s >= 1 && c >= 0; s--, c--) if (sampleLines[s] !== controlLines[c]) {
1477	if (s !== 1 \|\| c !== 1) do {
1478	s--;
1479	c--;
1480	if (c < 0 \|\| sampleLines[s] !== controlLines[c]) {
1481	var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
1482	if (fn.displayName && _frame.includes("<anonymous>")) _frame = _frame.replace("<anonymous>", fn.displayName);
1483	if (typeof fn === "function") componentFrameCache.set(fn, _frame);
1484	return _frame;
1485	}
1486	} while (s >= 1 && c >= 0);
1487	break;
1488	}
1489	}
1490	} finally {
1491	reentry = false;
1492	ReactCurrentDispatcher.current = previousDispatcher;
1493	reenableLogs();
1494	Error.prepareStackTrace = previousPrepareStackTrace;
1495	}
1496	var name = fn ? fn.displayName \|\| fn.name : "";
1497	var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
1498	if (typeof fn === "function") componentFrameCache.set(fn, syntheticFrame);
1499	return syntheticFrame;
1500	}
1501	function describeFunctionComponentFrame(fn, source, ownerFn) {
1502	return describeNativeComponentFrame(fn, false);
1503	}
1504	function shouldConstruct(Component) {
1505	var prototype = Component.prototype;
1506	return !!(prototype && prototype.isReactComponent);
1507	}
1508	function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
1509	if (type == null) return "";
1510	if (typeof type === "function") return describeNativeComponentFrame(type, shouldConstruct(type));
1511	if (typeof type === "string") return describeBuiltInComponentFrame(type);
1512	switch (type) {
1513	case REACT_SUSPENSE_TYPE: return describeBuiltInComponentFrame("Suspense");
1514	case REACT_SUSPENSE_LIST_TYPE: return describeBuiltInComponentFrame("SuspenseList");
1515	}
1516	if (typeof type === "object") switch (type.$$typeof) {
1517	case REACT_FORWARD_REF_TYPE: return describeFunctionComponentFrame(type.render);
1518	case REACT_MEMO_TYPE: return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
1519	case REACT_LAZY_TYPE:
1520	var lazyComponent = type;
1521	var payload = lazyComponent._payload;
1522	var init = lazyComponent._init;
1523	try {
1524	return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
1525	} catch (x) {}
1526	}
1527	return "";
1528	}
1529	var hasOwnProperty = Object.prototype.hasOwnProperty;
1530	var loggedTypeFailures = {};
1531	var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
1532	function setCurrentlyValidatingElement(element) {
1533	if (element) {
1534	var owner = element._owner;
1535	var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1536	ReactDebugCurrentFrame.setExtraStackFrame(stack);
1537	} else ReactDebugCurrentFrame.setExtraStackFrame(null);
1538	}
1539	function checkPropTypes(typeSpecs, values, location, componentName, element) {
1540	var has = Function.call.bind(hasOwnProperty);
1541	for (var typeSpecName in typeSpecs) if (has(typeSpecs, typeSpecName)) {
1542	var error$1 = void 0;
1543	try {
1544	if (typeof typeSpecs[typeSpecName] !== "function") {
1545	var err = Error((componentName \|\| "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
1546	err.name = "Invariant Violation";
1547	throw err;
1548	}
1549	error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
1550	} catch (ex) {
1551	error$1 = ex;
1552	}
1553	if (error$1 && !(error$1 instanceof Error)) {
1554	setCurrentlyValidatingElement(element);
1555	error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName \|\| "React class", location, typeSpecName, typeof error$1);
1556	setCurrentlyValidatingElement(null);
1557	}
1558	if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
1559	loggedTypeFailures[error$1.message] = true;
1560	setCurrentlyValidatingElement(element);
1561	error("Failed %s type: %s", location, error$1.message);
1562	setCurrentlyValidatingElement(null);
1563	}
1564	}
1565	}
1566	var isArrayImpl = Array.isArray;
1567	function isArray(a) {
1568	return isArrayImpl(a);
1569	}
1570	function typeName(value) {
1571	return typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] \|\| value.constructor.name \|\| "Object";
1572	}
1573	function willCoercionThrow(value) {
1574	try {
1575	testStringCoercion(value);
1576	return false;
1577	} catch (e) {
1578	return true;
1579	}
1580	}
1581	function testStringCoercion(value) {
1582	return "" + value;
1583	}
1584	function checkKeyStringCoercion(value) {
1585	if (willCoercionThrow(value)) {
1586	error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
1587	return testStringCoercion(value);
1588	}
1589	}
1590	var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
1591	var RESERVED_PROPS = {
1592	key: true,
1593	ref: true,
1594	__self: true,
1595	__source: true
1596	};
1597	var specialPropKeyWarningShown;
1598	var specialPropRefWarningShown;
1599	var didWarnAboutStringRefs = {};
1600	function hasValidRef(config) {
1601	if (hasOwnProperty.call(config, "ref")) {
1602	var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
1603	if (getter && getter.isReactWarning) return false;
1604	}
1605	return config.ref !== void 0;
1606	}
1607	function hasValidKey(config) {
1608	if (hasOwnProperty.call(config, "key")) {
1609	var getter = Object.getOwnPropertyDescriptor(config, "key").get;
1610	if (getter && getter.isReactWarning) return false;
1611	}
1612	return config.key !== void 0;
1613	}
1614	function warnIfStringRefCannotBeAutoConverted(config, self) {
1615	if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
1616	var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
1617	if (!didWarnAboutStringRefs[componentName]) {
1618	error("Component \"%s\" contains the string ref \"%s\". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref", getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
1619	didWarnAboutStringRefs[componentName] = true;
1620	}
1621	}
1622	}
1623	function defineKeyPropWarningGetter(props, displayName) {
1624	var warnAboutAccessingKey = function() {
1625	if (!specialPropKeyWarningShown) {
1626	specialPropKeyWarningShown = true;
1627	error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
1628	}
1629	};
1630	warnAboutAccessingKey.isReactWarning = true;
1631	Object.defineProperty(props, "key", {
1632	get: warnAboutAccessingKey,
1633	configurable: true
1634	});
1635	}
1636	function defineRefPropWarningGetter(props, displayName) {
1637	var warnAboutAccessingRef = function() {
1638	if (!specialPropRefWarningShown) {
1639	specialPropRefWarningShown = true;
1640	error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
1641	}
1642	};
1643	warnAboutAccessingRef.isReactWarning = true;
1644	Object.defineProperty(props, "ref", {
1645	get: warnAboutAccessingRef,
1646	configurable: true
1647	});
1648	}
1649	/**
1650	* Factory method to create a new React element. This no longer adheres to
1651	* the class pattern, so do not use new to call it. Also, instanceof check
1652	* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
1653	* if something is a React Element.
1654	*
1655	* @param {*} type
1656	* @param {*} props
1657	* @param {*} key
1658	* @param {string\|object} ref
1659	* @param {*} owner
1660	* @param {} self A temporary* helper to detect places where `this` is
1661	* different from the `owner` when React.createElement is called, so that we
1662	* can warn. We want to get rid of owner and replace string `ref`s with arrow
1663	* functions, and as long as `this` and owner are the same, there will be no
1664	* change in behavior.
1665	* @param {*} source An annotation object (added by a transpiler or otherwise)
1666	* indicating filename, line number, and/or other information.
1667	* @internal
1668	*/
1669	var ReactElement = function(type, key, ref, self, source, owner, props) {
1670	var element = {
1671	$$typeof: REACT_ELEMENT_TYPE,
1672	type,
1673	key,
1674	ref,
1675	props,
1676	_owner: owner
1677	};
1678	element._store = {};
1679	Object.defineProperty(element._store, "validated", {
1680	configurable: false,
1681	enumerable: false,
1682	writable: true,
1683	value: false
1684	});
1685	Object.defineProperty(element, "_self", {
1686	configurable: false,
1687	enumerable: false,
1688	writable: false,
1689	value: self
1690	});
1691	Object.defineProperty(element, "_source", {
1692	configurable: false,
1693	enumerable: false,
1694	writable: false,
1695	value: source
1696	});
1697	if (Object.freeze) {
1698	Object.freeze(element.props);
1699	Object.freeze(element);
1700	}
1701	return element;
1702	};
1703	/**
1704	* https://github.com/reactjs/rfcs/pull/107
1705	* @param {*} type
1706	* @param {object} props
1707	* @param {string} key
1708	*/
1709	function jsxDEV(type, config, maybeKey, source, self) {
1710	var propName;
1711	var props = {};
1712	var key = null;
1713	var ref = null;
1714	if (maybeKey !== void 0) {
1715	checkKeyStringCoercion(maybeKey);
1716	key = "" + maybeKey;
1717	}
1718	if (hasValidKey(config)) {
1719	checkKeyStringCoercion(config.key);
1720	key = "" + config.key;
1721	}
1722	if (hasValidRef(config)) {
1723	ref = config.ref;
1724	warnIfStringRefCannotBeAutoConverted(config, self);
1725	}
1726	for (propName in config) if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) props[propName] = config[propName];
1727	if (type && type.defaultProps) {
1728	var defaultProps = type.defaultProps;
1729	for (propName in defaultProps) if (props[propName] === void 0) props[propName] = defaultProps[propName];
1730	}
1731	if (key \|\| ref) {
1732	var displayName = typeof type === "function" ? type.displayName \|\| type.name \|\| "Unknown" : type;
1733	if (key) defineKeyPropWarningGetter(props, displayName);
1734	if (ref) defineRefPropWarningGetter(props, displayName);
1735	}
1736	return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
1737	}
1738	var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
1739	var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
1740	function setCurrentlyValidatingElement$1(element) {
1741	if (element) {
1742	var owner = element._owner;
1743	var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1744	ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
1745	} else ReactDebugCurrentFrame$1.setExtraStackFrame(null);
1746	}
1747	var propTypesMisspellWarningShown = false;
1748	/**
1749	* Verifies the object is a ReactElement.
1750	* See https://reactjs.org/docs/react-api.html#isvalidelement
1751	* @param {?object} object
1752	* @return {boolean} True if `object` is a ReactElement.
1753	* @final
1754	*/
1755	function isValidElement(object) {
1756	return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
1757	}
1758	function getDeclarationErrorAddendum() {
1759	if (ReactCurrentOwner$1.current) {
1760	var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
1761	if (name) return "\n\nCheck the render method of `" + name + "`.";
1762	}
1763	return "";
1764	}
1765	function getSourceInfoErrorAddendum(source) {
1766	if (source !== void 0) {
1767	var fileName = source.fileName.replace(/^.*[\\\/]/, "");
1768	var lineNumber = source.lineNumber;
1769	return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
1770	}
1771	return "";
1772	}
1773	/**
1774	* Warn if there's no key explicitly set on dynamic arrays of children or
1775	* object keys are not valid. This allows us to keep track of children between
1776	* updates.
1777	*/
1778	var ownerHasKeyUseWarning = {};
1779	function getCurrentComponentErrorInfo(parentType) {
1780	var info = getDeclarationErrorAddendum();
1781	if (!info) {
1782	var parentName = typeof parentType === "string" ? parentType : parentType.displayName \|\| parentType.name;
1783	if (parentName) info = "\n\nCheck the top-level render call using <" + parentName + ">.";
1784	}
1785	return info;
1786	}
1787	/**
1788	* Warn if the element doesn't have an explicit key assigned to it.
1789	* This element is in an array. The array could grow and shrink or be
1790	* reordered. All children that haven't already been validated are required to
1791	* have a "key" property assigned to it. Error statuses are cached so a warning
1792	* will only be shown once.
1793	*
1794	* @internal
1795	* @param {ReactElement} element Element that requires a key.
1796	* @param {*} parentType element's parent's type.
1797	*/
1798	function validateExplicitKey(element, parentType) {
1799	if (!element._store \|\| element._store.validated \|\| element.key != null) return;
1800	element._store.validated = true;
1801	var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
1802	if (ownerHasKeyUseWarning[currentComponentErrorInfo]) return;
1803	ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
1804	var childOwner = "";
1805	if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
1806	setCurrentlyValidatingElement$1(element);
1807	error("Each child in a list should have a unique \"key\" prop.%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, childOwner);
1808	setCurrentlyValidatingElement$1(null);
1809	}
1810	/**
1811	* Ensure that every element either is passed in a static location, in an
1812	* array with an explicit keys property defined, or in an object literal
1813	* with valid key property.
1814	*
1815	* @internal
1816	* @param {ReactNode} node Statically passed child of any type.
1817	* @param {*} parentType node's parent's type.
1818	*/
1819	function validateChildKeys(node, parentType) {
1820	if (typeof node !== "object") return;
1821	if (isArray(node)) for (var i = 0; i < node.length; i++) {
1822	var child = node[i];
1823	if (isValidElement(child)) validateExplicitKey(child, parentType);
1824	}
1825	else if (isValidElement(node)) {
1826	if (node._store) node._store.validated = true;
1827	} else if (node) {
1828	var iteratorFn = getIteratorFn(node);
1829	if (typeof iteratorFn === "function") {
1830	if (iteratorFn !== node.entries) {
1831	var iterator = iteratorFn.call(node);
1832	var step;
1833	while (!(step = iterator.next()).done) if (isValidElement(step.value)) validateExplicitKey(step.value, parentType);
1834	}
1835	}
1836	}
1837	}
1838	/**
1839	* Given an element, validate that its props follow the propTypes definition,
1840	* provided by the type.
1841	*
1842	* @param {ReactElement} element
1843	*/
1844	function validatePropTypes(element) {
1845	var type = element.type;
1846	if (type === null \|\| type === void 0 \|\| typeof type === "string") return;
1847	var propTypes;
1848	if (typeof type === "function") propTypes = type.propTypes;
1849	else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE \|\| type.$$typeof === REACT_MEMO_TYPE)) propTypes = type.propTypes;
1850	else return;
1851	if (propTypes) {
1852	var name = getComponentNameFromType(type);
1853	checkPropTypes(propTypes, element.props, "prop", name, element);
1854	} else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
1855	propTypesMisspellWarningShown = true;
1856	error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", getComponentNameFromType(type) \|\| "Unknown");
1857	}
1858	if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
1859	}
1860	/**
1861	* Given a fragment, validate that it can only be provided with fragment props
1862	* @param {ReactElement} fragment
1863	*/
1864	function validateFragmentProps(fragment) {
1865	var keys = Object.keys(fragment.props);
1866	for (var i = 0; i < keys.length; i++) {
1867	var key = keys[i];
1868	if (key !== "children" && key !== "key") {
1869	setCurrentlyValidatingElement$1(fragment);
1870	error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
1871	setCurrentlyValidatingElement$1(null);
1872	break;
1873	}
1874	}
1875	if (fragment.ref !== null) {
1876	setCurrentlyValidatingElement$1(fragment);
1877	error("Invalid attribute `ref` supplied to `React.Fragment`.");
1878	setCurrentlyValidatingElement$1(null);
1879	}
1880	}
1881	var didWarnAboutKeySpread = {};
1882	function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
1883	var validType = isValidElementType(type);
1884	if (!validType) {
1885	var info = "";
1886	if (type === void 0 \|\| typeof type === "object" && type !== null && Object.keys(type).length === 0) info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
1887	var sourceInfo = getSourceInfoErrorAddendum(source);
1888	if (sourceInfo) info += sourceInfo;
1889	else info += getDeclarationErrorAddendum();
1890	var typeString;
1891	if (type === null) typeString = "null";
1892	else if (isArray(type)) typeString = "array";
1893	else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
1894	typeString = "<" + (getComponentNameFromType(type.type) \|\| "Unknown") + " />";
1895	info = " Did you accidentally export a JSX literal instead of a component?";
1896	} else typeString = typeof type;
1897	error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
1898	}
1899	var element = jsxDEV(type, props, key, source, self);
1900	if (element == null) return element;
1901	if (validType) {
1902	var children = props.children;
1903	if (children !== void 0) if (isStaticChildren) if (isArray(children)) {
1904	for (var i = 0; i < children.length; i++) validateChildKeys(children[i], type);
1905	if (Object.freeze) Object.freeze(children);
1906	} else error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
1907	else validateChildKeys(children, type);
1908	}
1909	if (hasOwnProperty.call(props, "key")) {
1910	var componentName = getComponentNameFromType(type);
1911	var keys = Object.keys(props).filter(function(k) {
1912	return k !== "key";
1913	});
1914	var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
1915	if (!didWarnAboutKeySpread[componentName + beforeExample]) {
1916	error("A props object containing a \"key\" prop is being spread into JSX:\n let props = %s;\n <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n let props = %s;\n <%s key={someKey} {...props} />", beforeExample, componentName, keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}", componentName);
1917	didWarnAboutKeySpread[componentName + beforeExample] = true;
1918	}
1919	}
1920	if (type === REACT_FRAGMENT_TYPE) validateFragmentProps(element);
1921	else validatePropTypes(element);
1922	return element;
1923	}
1924	function jsxWithValidationStatic(type, props, key) {
1925	return jsxWithValidation(type, props, key, true);
1926	}
1927	function jsxWithValidationDynamic(type, props, key) {
1928	return jsxWithValidation(type, props, key, false);
1929	}
1930	var jsx = jsxWithValidationDynamic;
1931	var jsxs = jsxWithValidationStatic;
1932	exports.Fragment = REACT_FRAGMENT_TYPE;
1933	exports.jsx = jsx;
1934	exports.jsxs = jsxs;
1935	})();
1936	}));
1937
1938	//#endregion
1939	//#region node_modules/react/jsx-runtime.js
1940	var require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
1941	module.exports = require_react_jsx_runtime_development();
1942	}));
1943
1944	//#endregion
1945	//#region node_modules/@floating-ui/core/dist/floating-ui.core.mjs
1946	var import_jsx_runtime = require_jsx_runtime();
1947	function computeCoordsFromPlacement(_ref, placement, rtl) {
1948	let { reference, floating } = _ref;
1949	const sideAxis = getSideAxis(placement);
1950	const alignmentAxis = getAlignmentAxis(placement);
1951	const alignLength = getAxisLength(alignmentAxis);
1952	const side = getSide(placement);
1953	const isVertical = sideAxis === "y";
1954	const commonX = reference.x + reference.width / 2 - floating.width / 2;
1955	const commonY = reference.y + reference.height / 2 - floating.height / 2;
1956	const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
1957	let coords;
1958	switch (side) {
1959	case "top":
1960	coords = {
1961	x: commonX,
1962	y: reference.y - floating.height
1963	};
1964	break;
1965	case "bottom":
1966	coords = {
1967	x: commonX,
1968	y: reference.y + reference.height
1969	};
1970	break;
1971	case "right":
1972	coords = {
1973	x: reference.x + reference.width,
1974	y: commonY
1975	};
1976	break;
1977	case "left":
1978	coords = {
1979	x: reference.x - floating.width,
1980	y: commonY
1981	};
1982	break;
1983	default: coords = {
1984	x: reference.x,
1985	y: reference.y
1986	};
1987	}
1988	switch (getAlignment(placement)) {
1989	case "start":
1990	coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
1991	break;
1992	case "end":
1993	coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
1994	break;
1995	}
1996	return coords;
1997	}
1998	/**
1999	* Resolves with an object of overflow side offsets that determine how much the
2000	* element is overflowing a given clipping boundary on each side.
2001	* - positive = overflowing the boundary by that number of pixels
2002	* - negative = how many pixels left before it will overflow
2003	* - 0 = lies flush with the boundary
2004	* @see https://floating-ui.com/docs/detectOverflow
2005	*/
2006	async function detectOverflow(state, options) {
2007	var _await$platform$isEle;
2008	if (options === void 0) options = {};
2009	const { x, y, platform, rects, elements, strategy } = state;
2010	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = evaluate(options, state);
2011	const paddingObject = getPaddingObject(padding);
2012	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
2013	const clippingClientRect = rectToClientRect(await platform.getClippingRect({
2014	element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement \|\| await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
2015	boundary,
2016	rootBoundary,
2017	strategy
2018	}));
2019	const rect = elementContext === "floating" ? {
2020	x,
2021	y,
2022	width: rects.floating.width,
2023	height: rects.floating.height
2024	} : rects.reference;
2025	const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
2026	const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) \|\| {
2027	x: 1,
2028	y: 1
2029	} : {
2030	x: 1,
2031	y: 1
2032	};
2033	const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
2034	elements,
2035	rect,
2036	offsetParent,
2037	strategy
2038	}) : rect);
2039	return {
2040	top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
2041	bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
2042	left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
2043	right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
2044	};
2045	}
2046	var MAX_RESET_COUNT = 50;
2047	/**
2048	* Computes the `x` and `y` coordinates that will place the floating element
2049	* next to a given reference element.
2050	*
2051	* This export does not have any `platform` interface logic. You will need to
2052	* write one for the platform you are using Floating UI with.
2053	*/
2054	var computePosition$1 = /* @__PURE__ */ __name(async (reference, floating, config) => {
2055	const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
2056	const platformWithDetectOverflow = platform.detectOverflow ? platform : {
2057	...platform,
2058	detectOverflow
2059	};
2060	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
2061	let rects = await platform.getElementRects({
2062	reference,
2063	floating,
2064	strategy
2065	});
2066	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
2067	let statefulPlacement = placement;
2068	let resetCount = 0;
2069	const middlewareData = {};
2070	for (let i = 0; i < middleware.length; i++) {
2071	const currentMiddleware = middleware[i];
2072	if (!currentMiddleware) continue;
2073	const { name, fn } = currentMiddleware;
2074	const { x: nextX, y: nextY, data, reset } = await fn({
2075	x,
2076	y,
2077	initialPlacement: placement,
2078	placement: statefulPlacement,
2079	strategy,
2080	middlewareData,
2081	rects,
2082	platform: platformWithDetectOverflow,
2083	elements: {
2084	reference,
2085	floating
2086	}
2087	});
2088	x = nextX != null ? nextX : x;
2089	y = nextY != null ? nextY : y;
2090	middlewareData[name] = {
2091	...middlewareData[name],
2092	...data
2093	};
2094	if (reset && resetCount < MAX_RESET_COUNT) {
2095	resetCount++;
2096	if (typeof reset === "object") {
2097	if (reset.placement) statefulPlacement = reset.placement;
2098	if (reset.rects) rects = reset.rects === true ? await platform.getElementRects({
2099	reference,
2100	floating,
2101	strategy
2102	}) : reset.rects;
2103	({x, y} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
2104	}
2105	i = -1;
2106	}
2107	}
2108	return {
2109	x,
2110	y,
2111	placement: statefulPlacement,
2112	strategy,
2113	middlewareData
2114	};
2115	}, "computePosition");
2116	/**
2117	* Optimizes the visibility of the floating element by flipping the `placement`
2118	* in order to keep it in view when the preferred placement(s) will overflow the
2119	* clipping boundary. Alternative to `autoPlacement`.
2120	* @see https://floating-ui.com/docs/flip
2121	*/
2122	var flip$2 = /* @__PURE__ */ __name(function(options) {
2123	if (options === void 0) options = {};
2124	return {
2125	name: "flip",
2126	options,
2127	async fn(state) {
2128	var _middlewareData$arrow;
2129	var _middlewareData$flip;
2130	const { placement, middlewareData, rects, initialPlacement, platform, elements } = state;
2131	const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = "bestFit", fallbackAxisSideDirection = "none", flipAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
2132	if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
2133	const side = getSide(placement);
2134	const initialSideAxis = getSideAxis(initialPlacement);
2135	const isBasePlacement = getSide(initialPlacement) === initialPlacement;
2136	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
2137	const fallbackPlacements = specifiedFallbackPlacements \|\| (isBasePlacement \|\| !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
2138	const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
2139	if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
2140	const placements = [initialPlacement, ...fallbackPlacements];
2141	const overflow = await platform.detectOverflow(state, detectOverflowOptions);
2142	const overflows = [];
2143	let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) \|\| [];
2144	if (checkMainAxis) overflows.push(overflow[side]);
2145	if (checkCrossAxis) {
2146	const sides = getAlignmentSides(placement, rects, rtl);
2147	overflows.push(overflow[sides[0]], overflow[sides[1]]);
2148	}
2149	overflowsData = [...overflowsData, {
2150	placement,
2151	overflows
2152	}];
2153	if (!overflows.every((side) => side <= 0)) {
2154	var _middlewareData$flip2;
2155	var _overflowsData$filter;
2156	const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) \|\| 0) + 1;
2157	const nextPlacement = placements[nextIndex];
2158	if (nextPlacement) {
2159	if (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false) \|\| overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) return {
2160	data: {
2161	index: nextIndex,
2162	overflows: overflowsData
2163	},
2164	reset: { placement: nextPlacement }
2165	};
2166	}
2167	let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
2168	if (!resetPlacement) switch (fallbackStrategy) {
2169	case "bestFit": {
2170	var _overflowsData$filter2;
2171	const placement = (_overflowsData$filter2 = overflowsData.filter((d) => {
2172	if (hasFallbackAxisSideDirection) {
2173	const currentSideAxis = getSideAxis(d.placement);
2174	return currentSideAxis === initialSideAxis \|\| currentSideAxis === "y";
2175	}
2176	return true;
2177	}).map((d) => [d.placement, d.overflows.filter((overflow) => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
2178	if (placement) resetPlacement = placement;
2179	break;
2180	}
2181	case "initialPlacement":
2182	resetPlacement = initialPlacement;
2183	break;
2184	}
2185	if (placement !== resetPlacement) return { reset: { placement: resetPlacement } };
2186	}
2187	return {};
2188	}
2189	};
2190	}, "flip");
2191	var originSides = /#__PURE__/ new Set(["left", "top"]);
2192	async function convertValueToCoords(state, options) {
2193	const { placement, platform, elements } = state;
2194	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
2195	const side = getSide(placement);
2196	const alignment = getAlignment(placement);
2197	const isVertical = getSideAxis(placement) === "y";
2198	const mainAxisMulti = originSides.has(side) ? -1 : 1;
2199	const crossAxisMulti = rtl && isVertical ? -1 : 1;
2200	const rawValue = evaluate(options, state);
2201	let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === "number" ? {
2202	mainAxis: rawValue,
2203	crossAxis: 0,
2204	alignmentAxis: null
2205	} : {
2206	mainAxis: rawValue.mainAxis \|\| 0,
2207	crossAxis: rawValue.crossAxis \|\| 0,
2208	alignmentAxis: rawValue.alignmentAxis
2209	};
2210	if (alignment && typeof alignmentAxis === "number") crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
2211	return isVertical ? {
2212	x: crossAxis * crossAxisMulti,
2213	y: mainAxis * mainAxisMulti
2214	} : {
2215	x: mainAxis * mainAxisMulti,
2216	y: crossAxis * crossAxisMulti
2217	};
2218	}
2219	/**
2220	* Modifies the placement by translating the floating element along the
2221	* specified axes.
2222	* A number (shorthand for `mainAxis` or distance), or an axes configuration
2223	* object may be passed.
2224	* @see https://floating-ui.com/docs/offset
2225	*/
2226	var offset$2 = /* @__PURE__ */ __name(function(options) {
2227	if (options === void 0) options = 0;
2228	return {
2229	name: "offset",
2230	options,
2231	async fn(state) {
2232	var _middlewareData$offse;
2233	var _middlewareData$arrow;
2234	const { x, y, placement, middlewareData } = state;
2235	const diffCoords = await convertValueToCoords(state, options);
2236	if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
2237	return {
2238	x: x + diffCoords.x,
2239	y: y + diffCoords.y,
2240	data: {
2241	...diffCoords,
2242	placement
2243	}
2244	};
2245	}
2246	};
2247	}, "offset");
2248	/**
2249	* Provides data that allows you to change the size of the floating element —
2250	* for instance, prevent it from overflowing the clipping boundary or match the
2251	* width of the reference element.
2252	* @see https://floating-ui.com/docs/size
2253	*/
2254	var size$2 = /* @__PURE__ */ __name(function(options) {
2255	if (options === void 0) options = {};
2256	return {
2257	name: "size",
2258	options,
2259	async fn(state) {
2260	var _state$middlewareData;
2261	var _state$middlewareData2;
2262	const { placement, rects, platform, elements } = state;
2263	const { apply = () => {}, ...detectOverflowOptions } = evaluate(options, state);
2264	const overflow = await platform.detectOverflow(state, detectOverflowOptions);
2265	const side = getSide(placement);
2266	const alignment = getAlignment(placement);
2267	const isYAxis = getSideAxis(placement) === "y";
2268	const { width, height } = rects.floating;
2269	let heightSide;
2270	let widthSide;
2271	if (side === "top" \|\| side === "bottom") {
2272	heightSide = side;
2273	widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
2274	} else {
2275	widthSide = side;
2276	heightSide = alignment === "end" ? "top" : "bottom";
2277	}
2278	const maximumClippingHeight = height - overflow.top - overflow.bottom;
2279	const maximumClippingWidth = width - overflow.left - overflow.right;
2280	const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
2281	const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
2282	const noShift = !state.middlewareData.shift;
2283	let availableHeight = overflowAvailableHeight;
2284	let availableWidth = overflowAvailableWidth;
2285	if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
2286	if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
2287	if (noShift && !alignment) {
2288	const xMin = max(overflow.left, 0);
2289	const xMax = max(overflow.right, 0);
2290	const yMin = max(overflow.top, 0);
2291	const yMax = max(overflow.bottom, 0);
2292	if (isYAxis) availableWidth = width - 2 * (xMin !== 0 \|\| xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
2293	else availableHeight = height - 2 * (yMin !== 0 \|\| yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
2294	}
2295	await apply({
2296	...state,
2297	availableWidth,
2298	availableHeight
2299	});
2300	const nextDimensions = await platform.getDimensions(elements.floating);
2301	if (width !== nextDimensions.width \|\| height !== nextDimensions.height) return { reset: { rects: true } };
2302	return {};
2303	}
2304	};
2305	}, "size");
2306
2307	//#endregion
2308	//#region node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
2309	function getCssDimensions(element) {
2310	const css = getComputedStyle$1(element);
2311	let width = parseFloat(css.width) \|\| 0;
2312	let height = parseFloat(css.height) \|\| 0;
2313	const hasOffset = isHTMLElement(element);
2314	const offsetWidth = hasOffset ? element.offsetWidth : width;
2315	const offsetHeight = hasOffset ? element.offsetHeight : height;
2316	const shouldFallback = round(width) !== offsetWidth \|\| round(height) !== offsetHeight;
2317	if (shouldFallback) {
2318	width = offsetWidth;
2319	height = offsetHeight;
2320	}
2321	return {
2322	width,
2323	height,
2324	$: shouldFallback
2325	};
2326	}
2327	function unwrapElement(element) {
2328	return !isElement(element) ? element.contextElement : element;
2329	}
2330	function getScale(element) {
2331	const domElement = unwrapElement(element);
2332	if (!isHTMLElement(domElement)) return createCoords(1);
2333	const rect = domElement.getBoundingClientRect();
2334	const { width, height, $ } = getCssDimensions(domElement);
2335	let x = ($ ? round(rect.width) : rect.width) / width;
2336	let y = ($ ? round(rect.height) : rect.height) / height;
2337	if (!x \|\| !Number.isFinite(x)) x = 1;
2338	if (!y \|\| !Number.isFinite(y)) y = 1;
2339	return {
2340	x,
2341	y
2342	};
2343	}
2344	var noOffsets = /#__PURE__/ createCoords(0);
2345	function getVisualOffsets(element) {
2346	const win = getWindow(element);
2347	if (!isWebKit() \|\| !win.visualViewport) return noOffsets;
2348	return {
2349	x: win.visualViewport.offsetLeft,
2350	y: win.visualViewport.offsetTop
2351	};
2352	}
2353	function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
2354	if (isFixed === void 0) isFixed = false;
2355	if (!floatingOffsetParent \|\| isFixed && floatingOffsetParent !== getWindow(element)) return false;
2356	return isFixed;
2357	}
2358	function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
2359	if (includeScale === void 0) includeScale = false;
2360	if (isFixedStrategy === void 0) isFixedStrategy = false;
2361	const clientRect = element.getBoundingClientRect();
2362	const domElement = unwrapElement(element);
2363	let scale = createCoords(1);
2364	if (includeScale) if (offsetParent) {
2365	if (isElement(offsetParent)) scale = getScale(offsetParent);
2366	} else scale = getScale(element);
2367	const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
2368	let x = (clientRect.left + visualOffsets.x) / scale.x;
2369	let y = (clientRect.top + visualOffsets.y) / scale.y;
2370	let width = clientRect.width / scale.x;
2371	let height = clientRect.height / scale.y;
2372	if (domElement) {
2373	const win = getWindow(domElement);
2374	const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
2375	let currentWin = win;
2376	let currentIFrame = getFrameElement(currentWin);
2377	while (currentIFrame && offsetParent && offsetWin !== currentWin) {
2378	const iframeScale = getScale(currentIFrame);
2379	const iframeRect = currentIFrame.getBoundingClientRect();
2380	const css = getComputedStyle$1(currentIFrame);
2381	const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
2382	const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
2383	x *= iframeScale.x;
2384	y *= iframeScale.y;
2385	width *= iframeScale.x;
2386	height *= iframeScale.y;
2387	x += left;
2388	y += top;
2389	currentWin = getWindow(currentIFrame);
2390	currentIFrame = getFrameElement(currentWin);
2391	}
2392	}
2393	return rectToClientRect({
2394	width,
2395	height,
2396	x,
2397	y
2398	});
2399	}
2400	function getWindowScrollBarX(element, rect) {
2401	const leftScroll = getNodeScroll(element).scrollLeft;
2402	if (!rect) return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
2403	return rect.left + leftScroll;
2404	}
2405	function getHTMLOffset(documentElement, scroll) {
2406	const htmlRect = documentElement.getBoundingClientRect();
2407	return {
2408	x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
2409	y: htmlRect.top + scroll.scrollTop
2410	};
2411	}
2412	function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
2413	let { elements, rect, offsetParent, strategy } = _ref;
2414	const isFixed = strategy === "fixed";
2415	const documentElement = getDocumentElement(offsetParent);
2416	const topLayer = elements ? isTopLayer(elements.floating) : false;
2417	if (offsetParent === documentElement \|\| topLayer && isFixed) return rect;
2418	let scroll = {
2419	scrollLeft: 0,
2420	scrollTop: 0
2421	};
2422	let scale = createCoords(1);
2423	const offsets = createCoords(0);
2424	const isOffsetParentAnElement = isHTMLElement(offsetParent);
2425	if (isOffsetParentAnElement \|\| !isOffsetParentAnElement && !isFixed) {
2426	if (getNodeName(offsetParent) !== "body" \|\| isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
2427	if (isOffsetParentAnElement) {
2428	const offsetRect = getBoundingClientRect(offsetParent);
2429	scale = getScale(offsetParent);
2430	offsets.x = offsetRect.x + offsetParent.clientLeft;
2431	offsets.y = offsetRect.y + offsetParent.clientTop;
2432	}
2433	}
2434	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
2435	return {
2436	width: rect.width * scale.x,
2437	height: rect.height * scale.y,
2438	x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
2439	y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
2440	};
2441	}
2442	function getClientRects(element) {
2443	return Array.from(element.getClientRects());
2444	}
2445	function getDocumentRect(element) {
2446	const html = getDocumentElement(element);
2447	const scroll = getNodeScroll(element);
2448	const body = element.ownerDocument.body;
2449	const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
2450	const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
2451	let x = -scroll.scrollLeft + getWindowScrollBarX(element);
2452	const y = -scroll.scrollTop;
2453	if (getComputedStyle$1(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
2454	return {
2455	width,
2456	height,
2457	x,
2458	y
2459	};
2460	}
2461	var SCROLLBAR_MAX = 25;
2462	function getViewportRect(element, strategy) {
2463	const win = getWindow(element);
2464	const html = getDocumentElement(element);
2465	const visualViewport = win.visualViewport;
2466	let width = html.clientWidth;
2467	let height = html.clientHeight;
2468	let x = 0;
2469	let y = 0;
2470	if (visualViewport) {
2471	width = visualViewport.width;
2472	height = visualViewport.height;
2473	const visualViewportBased = isWebKit();
2474	if (!visualViewportBased \|\| visualViewportBased && strategy === "fixed") {
2475	x = visualViewport.offsetLeft;
2476	y = visualViewport.offsetTop;
2477	}
2478	}
2479	const windowScrollbarX = getWindowScrollBarX(html);
2480	if (windowScrollbarX <= 0) {
2481	const doc = html.ownerDocument;
2482	const body = doc.body;
2483	const bodyStyles = getComputedStyle(body);
2484	const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) \|\| 0 : 0;
2485	const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
2486	if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
2487	} else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
2488	return {
2489	width,
2490	height,
2491	x,
2492	y
2493	};
2494	}
2495	function getInnerBoundingClientRect(element, strategy) {
2496	const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
2497	const top = clientRect.top + element.clientTop;
2498	const left = clientRect.left + element.clientLeft;
2499	const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
2500	return {
2501	width: element.clientWidth * scale.x,
2502	height: element.clientHeight * scale.y,
2503	x: left * scale.x,
2504	y: top * scale.y
2505	};
2506	}
2507	function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
2508	let rect;
2509	if (clippingAncestor === "viewport") rect = getViewportRect(element, strategy);
2510	else if (clippingAncestor === "document") rect = getDocumentRect(getDocumentElement(element));
2511	else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
2512	else {
2513	const visualOffsets = getVisualOffsets(element);
2514	rect = {
2515	x: clippingAncestor.x - visualOffsets.x,
2516	y: clippingAncestor.y - visualOffsets.y,
2517	width: clippingAncestor.width,
2518	height: clippingAncestor.height
2519	};
2520	}
2521	return rectToClientRect(rect);
2522	}
2523	function hasFixedPositionAncestor(element, stopNode) {
2524	const parentNode = getParentNode(element);
2525	if (parentNode === stopNode \|\| !isElement(parentNode) \|\| isLastTraversableNode(parentNode)) return false;
2526	return getComputedStyle$1(parentNode).position === "fixed" \|\| hasFixedPositionAncestor(parentNode, stopNode);
2527	}
2528	function getClippingElementAncestors(element, cache) {
2529	const cachedResult = cache.get(element);
2530	if (cachedResult) return cachedResult;
2531	let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
2532	let currentContainingBlockComputedStyle = null;
2533	const elementIsFixed = getComputedStyle$1(element).position === "fixed";
2534	let currentNode = elementIsFixed ? getParentNode(element) : element;
2535	while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
2536	const computedStyle = getComputedStyle$1(currentNode);
2537	const currentNodeIsContaining = isContainingBlock(currentNode);
2538	if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
2539	if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" \|\| currentContainingBlockComputedStyle.position === "fixed") \|\| isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
2540	else currentContainingBlockComputedStyle = computedStyle;
2541	currentNode = getParentNode(currentNode);
2542	}
2543	cache.set(element, result);
2544	return result;
2545	}
2546	function getClippingRect(_ref) {
2547	let { element, boundary, rootBoundary, strategy } = _ref;
2548	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
2549	const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
2550	let top = firstRect.top;
2551	let right = firstRect.right;
2552	let bottom = firstRect.bottom;
2553	let left = firstRect.left;
2554	for (let i = 1; i < clippingAncestors.length; i++) {
2555	const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
2556	top = max(rect.top, top);
2557	right = min(rect.right, right);
2558	bottom = min(rect.bottom, bottom);
2559	left = max(rect.left, left);
2560	}
2561	return {
2562	width: right - left,
2563	height: bottom - top,
2564	x: left,
2565	y: top
2566	};
2567	}
2568	function getDimensions(element) {
2569	const { width, height } = getCssDimensions(element);
2570	return {
2571	width,
2572	height
2573	};
2574	}
2575	function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
2576	const isOffsetParentAnElement = isHTMLElement(offsetParent);
2577	const documentElement = getDocumentElement(offsetParent);
2578	const isFixed = strategy === "fixed";
2579	const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
2580	let scroll = {
2581	scrollLeft: 0,
2582	scrollTop: 0
2583	};
2584	const offsets = createCoords(0);
2585	function setLeftRTLScrollbarOffset() {
2586	offsets.x = getWindowScrollBarX(documentElement);
2587	}
2588	if (isOffsetParentAnElement \|\| !isOffsetParentAnElement && !isFixed) {
2589	if (getNodeName(offsetParent) !== "body" \|\| isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
2590	if (isOffsetParentAnElement) {
2591	const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
2592	offsets.x = offsetRect.x + offsetParent.clientLeft;
2593	offsets.y = offsetRect.y + offsetParent.clientTop;
2594	} else if (documentElement) setLeftRTLScrollbarOffset();
2595	}
2596	if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
2597	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
2598	return {
2599	x: rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x,
2600	y: rect.top + scroll.scrollTop - offsets.y - htmlOffset.y,
2601	width: rect.width,
2602	height: rect.height
2603	};
2604	}
2605	function isStaticPositioned(element) {
2606	return getComputedStyle$1(element).position === "static";
2607	}
2608	function getTrueOffsetParent(element, polyfill) {
2609	if (!isHTMLElement(element) \|\| getComputedStyle$1(element).position === "fixed") return null;
2610	if (polyfill) return polyfill(element);
2611	let rawOffsetParent = element.offsetParent;
2612	if (getDocumentElement(element) === rawOffsetParent) rawOffsetParent = rawOffsetParent.ownerDocument.body;
2613	return rawOffsetParent;
2614	}
2615	function getOffsetParent(element, polyfill) {
2616	const win = getWindow(element);
2617	if (isTopLayer(element)) return win;
2618	if (!isHTMLElement(element)) {
2619	let svgOffsetParent = getParentNode(element);
2620	while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
2621	if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) return svgOffsetParent;
2622	svgOffsetParent = getParentNode(svgOffsetParent);
2623	}
2624	return win;
2625	}
2626	let offsetParent = getTrueOffsetParent(element, polyfill);
2627	while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) offsetParent = getTrueOffsetParent(offsetParent, polyfill);
2628	if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) return win;
2629	return offsetParent \|\| getContainingBlock(element) \|\| win;
2630	}
2631	var getElementRects = async function(data) {
2632	const getOffsetParentFn = this.getOffsetParent \|\| getOffsetParent;
2633	const getDimensionsFn = this.getDimensions;
2634	const floatingDimensions = await getDimensionsFn(data.floating);
2635	return {
2636	reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
2637	floating: {
2638	x: 0,
2639	y: 0,
2640	width: floatingDimensions.width,
2641	height: floatingDimensions.height
2642	}
2643	};
2644	};
2645	function isRTL(element) {
2646	return getComputedStyle$1(element).direction === "rtl";
2647	}
2648	var platform = {
2649	convertOffsetParentRelativeRectToViewportRelativeRect,
2650	getDocumentElement,
2651	getClippingRect,
2652	getOffsetParent,
2653	getElementRects,
2654	getClientRects,
2655	getDimensions,
2656	getScale,
2657	isElement,
2658	isRTL
2659	};
2660	function rectsAreEqual(a, b) {
2661	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
2662	}
2663	function observeMove(element, onMove) {
2664	let io = null;
2665	let timeoutId;
2666	const root = getDocumentElement(element);
2667	function cleanup() {
2668	var _io;
2669	clearTimeout(timeoutId);
2670	(_io = io) == null \|\| _io.disconnect();
2671	io = null;
2672	}
2673	function refresh(skip, threshold) {
2674	if (skip === void 0) skip = false;
2675	if (threshold === void 0) threshold = 1;
2676	cleanup();
2677	const elementRectForRootMargin = element.getBoundingClientRect();
2678	const { left, top, width, height } = elementRectForRootMargin;
2679	if (!skip) onMove();
2680	if (!width \|\| !height) return;
2681	const insetTop = floor(top);
2682	const insetRight = floor(root.clientWidth - (left + width));
2683	const insetBottom = floor(root.clientHeight - (top + height));
2684	const insetLeft = floor(left);
2685	const options = {
2686	rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
2687	threshold: max(0, min(1, threshold)) \|\| 1
2688	};
2689	let isFirstUpdate = true;
2690	function handleObserve(entries) {
2691	const ratio = entries[0].intersectionRatio;
2692	if (ratio !== threshold) {
2693	if (!isFirstUpdate) return refresh();
2694	if (!ratio) timeoutId = setTimeout(() => {
2695	refresh(false, 1e-7);
2696	}, 1e3);
2697	else refresh(false, ratio);
2698	}
2699	if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
2700	isFirstUpdate = false;
2701	}
2702	try {
2703	io = new IntersectionObserver(handleObserve, {
2704	...options,
2705	root: root.ownerDocument
2706	});
2707	} catch (_e) {
2708	io = new IntersectionObserver(handleObserve, options);
2709	}
2710	io.observe(element);
2711	}
2712	refresh(true);
2713	return cleanup;
2714	}
2715	/**
2716	* Automatically updates the position of the floating element when necessary.
2717	* Should only be called when the floating element is mounted on the DOM or
2718	* visible on the screen.
2719	* @returns cleanup function that should be invoked when the floating element is
2720	* removed from the DOM or hidden from the screen.
2721	* @see https://floating-ui.com/docs/autoUpdate
2722	*/
2723	function autoUpdate(reference, floating, update, options) {
2724	if (options === void 0) options = {};
2725	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
2726	const referenceEl = unwrapElement(reference);
2727	const ancestors = ancestorScroll \|\| ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
2728	ancestors.forEach((ancestor) => {
2729	ancestorScroll && ancestor.addEventListener("scroll", update, { passive: true });
2730	ancestorResize && ancestor.addEventListener("resize", update);
2731	});
2732	const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
2733	let reobserveFrame = -1;
2734	let resizeObserver = null;
2735	if (elementResize) {
2736	resizeObserver = new ResizeObserver((_ref) => {
2737	let [firstEntry] = _ref;
2738	if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
2739	resizeObserver.unobserve(floating);
2740	cancelAnimationFrame(reobserveFrame);
2741	reobserveFrame = requestAnimationFrame(() => {
2742	var _resizeObserver;
2743	(_resizeObserver = resizeObserver) == null \|\| _resizeObserver.observe(floating);
2744	});
2745	}
2746	update();
2747	});
2748	if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
2749	if (floating) resizeObserver.observe(floating);
2750	}
2751	let frameId;
2752	let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
2753	if (animationFrame) frameLoop();
2754	function frameLoop() {
2755	const nextRefRect = getBoundingClientRect(reference);
2756	if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) update();
2757	prevRefRect = nextRefRect;
2758	frameId = requestAnimationFrame(frameLoop);
2759	}
2760	update();
2761	return () => {
2762	var _resizeObserver2;
2763	ancestors.forEach((ancestor) => {
2764	ancestorScroll && ancestor.removeEventListener("scroll", update);
2765	ancestorResize && ancestor.removeEventListener("resize", update);
2766	});
2767	cleanupIo?.();
2768	(_resizeObserver2 = resizeObserver) == null \|\| _resizeObserver2.disconnect();
2769	resizeObserver = null;
2770	if (animationFrame) cancelAnimationFrame(frameId);
2771	};
2772	}
2773	/**
2774	* Modifies the placement by translating the floating element along the
2775	* specified axes.
2776	* A number (shorthand for `mainAxis` or distance), or an axes configuration
2777	* object may be passed.
2778	* @see https://floating-ui.com/docs/offset
2779	*/
2780	var offset$1 = offset$2;
2781	/**
2782	* Optimizes the visibility of the floating element by flipping the `placement`
2783	* in order to keep it in view when the preferred placement(s) will overflow the
2784	* clipping boundary. Alternative to `autoPlacement`.
2785	* @see https://floating-ui.com/docs/flip
2786	*/
2787	var flip$1 = flip$2;
2788	/**
2789	* Provides data that allows you to change the size of the floating element —
2790	* for instance, prevent it from overflowing the clipping boundary or match the
2791	* width of the reference element.
2792	* @see https://floating-ui.com/docs/size
2793	*/
2794	var size$1 = size$2;
2795	/**
2796	* Computes the `x` and `y` coordinates that will place the floating element
2797	* next to a given reference element.
2798	*/
2799	var computePosition = (reference, floating, options) => {
2800	const cache = /* @__PURE__ */ new Map();
2801	const mergedOptions = {
2802	platform,
2803	...options
2804	};
2805	const platformWithCache = {
2806	...mergedOptions.platform,
2807	_c: cache
2808	};
2809	return computePosition$1(reference, floating, {
2810	...mergedOptions,
2811	platform: platformWithCache
2812	});
2813	};
2814
2815	//#endregion
2816	//#region node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
2817	var index = typeof document !== "undefined" ? react$1.useLayoutEffect : function noop() {};
2818	function deepEqual(a, b) {
2819	if (a === b) return true;
2820	if (typeof a !== typeof b) return false;
2821	if (typeof a === "function" && a.toString() === b.toString()) return true;
2822	let length;
2823	let i;
2824	let keys;
2825	if (a && b && typeof a === "object") {
2826	if (Array.isArray(a)) {
2827	length = a.length;
2828	if (length !== b.length) return false;
2829	for (i = length; i-- !== 0;) if (!deepEqual(a[i], b[i])) return false;
2830	return true;
2831	}
2832	keys = Object.keys(a);
2833	length = keys.length;
2834	if (length !== Object.keys(b).length) return false;
2835	for (i = length; i-- !== 0;) if (!{}.hasOwnProperty.call(b, keys[i])) return false;
2836	for (i = length; i-- !== 0;) {
2837	const key = keys[i];
2838	if (key === "_owner" && a.$$typeof) continue;
2839	if (!deepEqual(a[key], b[key])) return false;
2840	}
2841	return true;
2842	}
2843	return a !== a && b !== b;
2844	}
2845	function getDPR(element) {
2846	if (typeof window === "undefined") return 1;
2847	return (element.ownerDocument.defaultView \|\| window).devicePixelRatio \|\| 1;
2848	}
2849	function roundByDPR(element, value) {
2850	const dpr = getDPR(element);
2851	return Math.round(value * dpr) / dpr;
2852	}
2853	function useLatestRef(value) {
2854	const ref = react$1.useRef(value);
2855	index(() => {
2856	ref.current = value;
2857	});
2858	return ref;
2859	}
2860	/**
2861	* Provides data to position a floating element.
2862	* @see https://floating-ui.com/docs/useFloating
2863	*/
2864	function useFloating$1(options) {
2865	if (options === void 0) options = {};
2866	const { placement = "bottom", strategy = "absolute", middleware = [], platform, elements: { reference: externalReference, floating: externalFloating } = {}, transform = true, whileElementsMounted, open } = options;
2867	const [data, setData] = react$1.useState({
2868	x: 0,
2869	y: 0,
2870	strategy,
2871	placement,
2872	middlewareData: {},
2873	isPositioned: false
2874	});
2875	const [latestMiddleware, setLatestMiddleware] = react$1.useState(middleware);
2876	if (!deepEqual(latestMiddleware, middleware)) setLatestMiddleware(middleware);
2877	const [_reference, _setReference] = react$1.useState(null);
2878	const [_floating, _setFloating] = react$1.useState(null);
2879	const setReference = react$1.useCallback((node) => {
2880	if (node !== referenceRef.current) {
2881	referenceRef.current = node;
2882	_setReference(node);
2883	}
2884	}, []);
2885	const setFloating = react$1.useCallback((node) => {
2886	if (node !== floatingRef.current) {
2887	floatingRef.current = node;
2888	_setFloating(node);
2889	}
2890	}, []);
2891	const referenceEl = externalReference \|\| _reference;
2892	const floatingEl = externalFloating \|\| _floating;
2893	const referenceRef = react$1.useRef(null);
2894	const floatingRef = react$1.useRef(null);
2895	const dataRef = react$1.useRef(data);
2896	const hasWhileElementsMounted = whileElementsMounted != null;
2897	const whileElementsMountedRef = useLatestRef(whileElementsMounted);
2898	const platformRef = useLatestRef(platform);
2899	const openRef = useLatestRef(open);
2900	const update = react$1.useCallback(() => {
2901	if (!referenceRef.current \|\| !floatingRef.current) return;
2902	const config = {
2903	placement,
2904	strategy,
2905	middleware: latestMiddleware
2906	};
2907	if (platformRef.current) config.platform = platformRef.current;
2908	computePosition(referenceRef.current, floatingRef.current, config).then((data) => {
2909	const fullData = {
2910	...data,
2911	isPositioned: openRef.current !== false
2912	};
2913	if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
2914	dataRef.current = fullData;
2915	react_dom.flushSync(() => {
2916	setData(fullData);
2917	});
2918	}
2919	});
2920	}, [
2921	latestMiddleware,
2922	placement,
2923	strategy,
2924	platformRef,
2925	openRef
2926	]);
2927	index(() => {
2928	if (open === false && dataRef.current.isPositioned) {
2929	dataRef.current.isPositioned = false;
2930	setData((data) => ({
2931	...data,
2932	isPositioned: false
2933	}));
2934	}
2935	}, [open]);
2936	const isMountedRef = react$1.useRef(false);
2937	index(() => {
2938	isMountedRef.current = true;
2939	return () => {
2940	isMountedRef.current = false;
2941	};
2942	}, []);
2943	index(() => {
2944	if (referenceEl) referenceRef.current = referenceEl;
2945	if (floatingEl) floatingRef.current = floatingEl;
2946	if (referenceEl && floatingEl) {
2947	if (whileElementsMountedRef.current) return whileElementsMountedRef.current(referenceEl, floatingEl, update);
2948	update();
2949	}
2950	}, [
2951	referenceEl,
2952	floatingEl,
2953	update,
2954	whileElementsMountedRef,
2955	hasWhileElementsMounted
2956	]);
2957	const refs = react$1.useMemo(() => ({
2958	reference: referenceRef,
2959	floating: floatingRef,
2960	setReference,
2961	setFloating
2962	}), [setReference, setFloating]);
2963	const elements = react$1.useMemo(() => ({
2964	reference: referenceEl,
2965	floating: floatingEl
2966	}), [referenceEl, floatingEl]);
2967	const floatingStyles = react$1.useMemo(() => {
2968	const initialStyles = {
2969	position: strategy,
2970	left: 0,
2971	top: 0
2972	};
2973	if (!elements.floating) return initialStyles;
2974	const x = roundByDPR(elements.floating, data.x);
2975	const y = roundByDPR(elements.floating, data.y);
2976	if (transform) return {
2977	...initialStyles,
2978	transform: "translate(" + x + "px, " + y + "px)",
2979	...getDPR(elements.floating) >= 1.5 && { willChange: "transform" }
2980	};
2981	return {
2982	position: strategy,
2983	left: x,
2984	top: y
2985	};
2986	}, [
2987	strategy,
2988	transform,
2989	elements.floating,
2990	data.x,
2991	data.y
2992	]);
2993	return react$1.useMemo(() => ({
2994	...data,
2995	update,
2996	refs,
2997	elements,
2998	floatingStyles
2999	}), [
3000	data,
3001	update,
3002	refs,
3003	elements,
3004	floatingStyles
3005	]);
3006	}
3007	__name(useFloating$1, "useFloating");
3008	/**
3009	* Modifies the placement by translating the floating element along the
3010	* specified axes.
3011	* A number (shorthand for `mainAxis` or distance), or an axes configuration
3012	* object may be passed.
3013	* @see https://floating-ui.com/docs/offset
3014	*/
3015	var offset = (options, deps) => {
3016	const result = offset$1(options);
3017	return {
3018	name: result.name,
3019	fn: result.fn,
3020	options: [options, deps]
3021	};
3022	};
3023	/**
3024	* Optimizes the visibility of the floating element by flipping the `placement`
3025	* in order to keep it in view when the preferred placement(s) will overflow the
3026	* clipping boundary. Alternative to `autoPlacement`.
3027	* @see https://floating-ui.com/docs/flip
3028	*/
3029	var flip = (options, deps) => {
3030	const result = flip$1(options);
3031	return {
3032	name: result.name,
3033	fn: result.fn,
3034	options: [options, deps]
3035	};
3036	};
3037	/**
3038	* Provides data that allows you to change the size of the floating element —
3039	* for instance, prevent it from overflowing the clipping boundary or match the
3040	* width of the reference element.
3041	* @see https://floating-ui.com/docs/size
3042	*/
3043	var size = (options, deps) => {
3044	const result = size$1(options);
3045	return {
3046	name: result.name,
3047	fn: result.fn,
3048	options: [options, deps]
3049	};
3050	};
3051
3052	//#endregion
3053	//#region node_modules/@floating-ui/react/dist/floating-ui.react.mjs
3054	var FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
3055	var ACTIVE_KEY = "active";
3056	var SELECTED_KEY = "selected";
3057	var ARROW_LEFT = "ArrowLeft";
3058	var ARROW_RIGHT = "ArrowRight";
3059	var ARROW_UP = "ArrowUp";
3060	var ARROW_DOWN = "ArrowDown";
3061	var horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];
3062	var verticalKeys = [ARROW_UP, ARROW_DOWN];
3063	var allKeys = [...horizontalKeys, ...verticalKeys];
3064	var SafeReact = { ...react$1 };
3065	var serverHandoffComplete = false;
3066	var count = 0;
3067	var genId = () => "floating-ui-" + Math.random().toString(36).slice(2, 6) + count++;
3068	function useFloatingId() {
3069	const [id, setId] = react$1.useState(() => serverHandoffComplete ? genId() : void 0);
3070	index$1(() => {
3071	if (id == null) setId(genId());
3072	}, []);
3073	react$1.useEffect(() => {
3074	serverHandoffComplete = true;
3075	}, []);
3076	return id;
3077	}
3078	/**
3079	* Uses React 18's built-in `useId()` when available, or falls back to a
3080	* slightly less performant (requiring a double render) implementation for
3081	* earlier React versions.
3082	* @see https://floating-ui.com/docs/react-utils#useid
3083	*/
3084	var useId = SafeReact.useId \|\| useFloatingId;
3085	var devMessageSet;
3086	devMessageSet = /#__PURE__/ new Set();
3087	function error() {
3088	var _devMessageSet3;
3089	for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) messages[_key2] = arguments[_key2];
3090	const message = "Floating UI: " + messages.join(" ");
3091	if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {
3092	var _devMessageSet4;
3093	(_devMessageSet4 = devMessageSet) == null \|\| _devMessageSet4.add(message);
3094	console.error(message);
3095	}
3096	}
3097	function createEventEmitter() {
3098	const map = /* @__PURE__ */ new Map();
3099	return {
3100	emit(event, data) {
3101	var _map$get;
3102	(_map$get = map.get(event)) == null \|\| _map$get.forEach((listener) => listener(data));
3103	},
3104	on(event, listener) {
3105	if (!map.has(event)) map.set(event, /* @__PURE__ */ new Set());
3106	map.get(event).add(listener);
3107	},
3108	off(event, listener) {
3109	var _map$get2;
3110	(_map$get2 = map.get(event)) == null \|\| _map$get2.delete(listener);
3111	}
3112	};
3113	}
3114	var FloatingNodeContext = /#__PURE__/ react$1.createContext(null);
3115	var FloatingTreeContext = /#__PURE__/ react$1.createContext(null);
3116	/**
3117	* Returns the parent node id for nested floating elements, if available.
3118	* Returns `null` for top-level floating elements.
3119	*/
3120	var useFloatingParentNodeId = () => {
3121	var _React$useContext;
3122	return ((_React$useContext = react$1.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) \|\| null;
3123	};
3124	/**
3125	* Returns the nearest floating tree context, if available.
3126	*/
3127	var useFloatingTree = () => react$1.useContext(FloatingTreeContext);
3128	function createAttribute(name) {
3129	return "data-floating-ui-" + name;
3130	}
3131	function clearTimeoutIfSet(timeoutRef) {
3132	if (timeoutRef.current !== -1) {
3133	clearTimeout(timeoutRef.current);
3134	timeoutRef.current = -1;
3135	}
3136	}
3137	var safePolygonIdentifier = /#__PURE__/ createAttribute("safe-polygon");
3138	function getDelay(value, prop, pointerType) {
3139	if (pointerType && !isMouseLikePointerType(pointerType)) return 0;
3140	if (typeof value === "number") return value;
3141	if (typeof value === "function") {
3142	const result = value();
3143	if (typeof result === "number") return result;
3144	return result == null ? void 0 : result[prop];
3145	}
3146	return value == null ? void 0 : value[prop];
3147	}
3148	function getRestMs(value) {
3149	if (typeof value === "function") return value();
3150	return value;
3151	}
3152	/**
3153	* Opens the floating element while hovering over the reference element, like
3154	* CSS `:hover`.
3155	* @see https://floating-ui.com/docs/useHover
3156	*/
3157	function useHover(context, props) {
3158	if (props === void 0) props = {};
3159	const { open, onOpenChange, dataRef, events, elements } = context;
3160	const { enabled = true, delay = 0, handleClose = null, mouseOnly = false, restMs = 0, move = true } = props;
3161	const tree = useFloatingTree();
3162	const parentId = useFloatingParentNodeId();
3163	const handleCloseRef = useLatestRef$1(handleClose);
3164	const delayRef = useLatestRef$1(delay);
3165	const openRef = useLatestRef$1(open);
3166	const restMsRef = useLatestRef$1(restMs);
3167	const pointerTypeRef = react$1.useRef();
3168	const timeoutRef = react$1.useRef(-1);
3169	const handlerRef = react$1.useRef();
3170	const restTimeoutRef = react$1.useRef(-1);
3171	const blockMouseMoveRef = react$1.useRef(true);
3172	const performedPointerEventsMutationRef = react$1.useRef(false);
3173	const unbindMouseMoveRef = react$1.useRef(() => {});
3174	const restTimeoutPendingRef = react$1.useRef(false);
3175	const isHoverOpen = useEffectEvent(() => {
3176	var _dataRef$current$open;
3177	const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;
3178	return (type == null ? void 0 : type.includes("mouse")) && type !== "mousedown";
3179	});
3180	react$1.useEffect(() => {
3181	if (!enabled) return;
3182	function onOpenChange(_ref) {
3183	let { open } = _ref;
3184	if (!open) {
3185	clearTimeoutIfSet(timeoutRef);
3186	clearTimeoutIfSet(restTimeoutRef);
3187	blockMouseMoveRef.current = true;
3188	restTimeoutPendingRef.current = false;
3189	}
3190	}
3191	events.on("openchange", onOpenChange);
3192	return () => {
3193	events.off("openchange", onOpenChange);
3194	};
3195	}, [enabled, events]);
3196	react$1.useEffect(() => {
3197	if (!enabled) return;
3198	if (!handleCloseRef.current) return;
3199	if (!open) return;
3200	function onLeave(event) {
3201	if (isHoverOpen()) onOpenChange(false, event, "hover");
3202	}
3203	const html = getDocument(elements.floating).documentElement;
3204	html.addEventListener("mouseleave", onLeave);
3205	return () => {
3206	html.removeEventListener("mouseleave", onLeave);
3207	};
3208	}, [
3209	elements.floating,
3210	open,
3211	onOpenChange,
3212	enabled,
3213	handleCloseRef,
3214	isHoverOpen
3215	]);
3216	const closeWithDelay = react$1.useCallback(function(event, runElseBranch, reason) {
3217	if (runElseBranch === void 0) runElseBranch = true;
3218	if (reason === void 0) reason = "hover";
3219	const closeDelay = getDelay(delayRef.current, "close", pointerTypeRef.current);
3220	if (closeDelay && !handlerRef.current) {
3221	clearTimeoutIfSet(timeoutRef);
3222	timeoutRef.current = window.setTimeout(() => onOpenChange(false, event, reason), closeDelay);
3223	} else if (runElseBranch) {
3224	clearTimeoutIfSet(timeoutRef);
3225	onOpenChange(false, event, reason);
3226	}
3227	}, [delayRef, onOpenChange]);
3228	const cleanupMouseMoveHandler = useEffectEvent(() => {
3229	unbindMouseMoveRef.current();
3230	handlerRef.current = void 0;
3231	});
3232	const clearPointerEvents = useEffectEvent(() => {
3233	if (performedPointerEventsMutationRef.current) {
3234	const body = getDocument(elements.floating).body;
3235	body.style.pointerEvents = "";
3236	body.removeAttribute(safePolygonIdentifier);
3237	performedPointerEventsMutationRef.current = false;
3238	}
3239	});
3240	const isClickLikeOpenEvent = useEffectEvent(() => {
3241	return dataRef.current.openEvent ? ["click", "mousedown"].includes(dataRef.current.openEvent.type) : false;
3242	});
3243	react$1.useEffect(() => {
3244	if (!enabled) return;
3245	function onReferenceMouseEnter(event) {
3246	clearTimeoutIfSet(timeoutRef);
3247	blockMouseMoveRef.current = false;
3248	if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) \|\| getRestMs(restMsRef.current) > 0 && !getDelay(delayRef.current, "open")) return;
3249	const openDelay = getDelay(delayRef.current, "open", pointerTypeRef.current);
3250	if (openDelay) timeoutRef.current = window.setTimeout(() => {
3251	if (!openRef.current) onOpenChange(true, event, "hover");
3252	}, openDelay);
3253	else if (!open) onOpenChange(true, event, "hover");
3254	}
3255	function onReferenceMouseLeave(event) {
3256	if (isClickLikeOpenEvent()) {
3257	clearPointerEvents();
3258	return;
3259	}
3260	unbindMouseMoveRef.current();
3261	const doc = getDocument(elements.floating);
3262	clearTimeoutIfSet(restTimeoutRef);
3263	restTimeoutPendingRef.current = false;
3264	if (handleCloseRef.current && dataRef.current.floatingContext) {
3265	if (!open) clearTimeoutIfSet(timeoutRef);
3266	handlerRef.current = handleCloseRef.current({
3267	...dataRef.current.floatingContext,
3268	tree,
3269	x: event.clientX,
3270	y: event.clientY,
3271	onClose() {
3272	clearPointerEvents();
3273	cleanupMouseMoveHandler();
3274	if (!isClickLikeOpenEvent()) closeWithDelay(event, true, "safe-polygon");
3275	}
3276	});
3277	const handler = handlerRef.current;
3278	doc.addEventListener("mousemove", handler);
3279	unbindMouseMoveRef.current = () => {
3280	doc.removeEventListener("mousemove", handler);
3281	};
3282	return;
3283	}
3284	if (pointerTypeRef.current === "touch" ? !contains(elements.floating, event.relatedTarget) : true) closeWithDelay(event);
3285	}
3286	function onScrollMouseLeave(event) {
3287	if (isClickLikeOpenEvent()) return;
3288	if (!dataRef.current.floatingContext) return;
3289	handleCloseRef.current == null \|\| handleCloseRef.current({
3290	...dataRef.current.floatingContext,
3291	tree,
3292	x: event.clientX,
3293	y: event.clientY,
3294	onClose() {
3295	clearPointerEvents();
3296	cleanupMouseMoveHandler();
3297	if (!isClickLikeOpenEvent()) closeWithDelay(event);
3298	}
3299	})(event);
3300	}
3301	function onFloatingMouseEnter() {
3302	clearTimeoutIfSet(timeoutRef);
3303	}
3304	function onFloatingMouseLeave(event) {
3305	if (!isClickLikeOpenEvent()) closeWithDelay(event, false);
3306	}
3307	if (isElement(elements.domReference)) {
3308	const reference = elements.domReference;
3309	const floating = elements.floating;
3310	if (open) reference.addEventListener("mouseleave", onScrollMouseLeave);
3311	if (move) reference.addEventListener("mousemove", onReferenceMouseEnter, { once: true });
3312	reference.addEventListener("mouseenter", onReferenceMouseEnter);
3313	reference.addEventListener("mouseleave", onReferenceMouseLeave);
3314	if (floating) {
3315	floating.addEventListener("mouseleave", onScrollMouseLeave);
3316	floating.addEventListener("mouseenter", onFloatingMouseEnter);
3317	floating.addEventListener("mouseleave", onFloatingMouseLeave);
3318	}
3319	return () => {
3320	if (open) reference.removeEventListener("mouseleave", onScrollMouseLeave);
3321	if (move) reference.removeEventListener("mousemove", onReferenceMouseEnter);
3322	reference.removeEventListener("mouseenter", onReferenceMouseEnter);
3323	reference.removeEventListener("mouseleave", onReferenceMouseLeave);
3324	if (floating) {
3325	floating.removeEventListener("mouseleave", onScrollMouseLeave);
3326	floating.removeEventListener("mouseenter", onFloatingMouseEnter);
3327	floating.removeEventListener("mouseleave", onFloatingMouseLeave);
3328	}
3329	};
3330	}
3331	}, [
3332	elements,
3333	enabled,
3334	context,
3335	mouseOnly,
3336	move,
3337	closeWithDelay,
3338	cleanupMouseMoveHandler,
3339	clearPointerEvents,
3340	onOpenChange,
3341	open,
3342	openRef,
3343	tree,
3344	delayRef,
3345	handleCloseRef,
3346	dataRef,
3347	isClickLikeOpenEvent,
3348	restMsRef
3349	]);
3350	index$1(() => {
3351	var _handleCloseRef$curre;
3352	if (!enabled) return;
3353	if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && (_handleCloseRef$curre = _handleCloseRef$curre.__options) != null && _handleCloseRef$curre.blockPointerEvents && isHoverOpen()) {
3354	performedPointerEventsMutationRef.current = true;
3355	const floatingEl = elements.floating;
3356	if (isElement(elements.domReference) && floatingEl) {
3357	var _tree$nodesRef$curren;
3358	const body = getDocument(elements.floating).body;
3359	body.setAttribute(safePolygonIdentifier, "");
3360	const ref = elements.domReference;
3361	const parentFloating = tree == null \|\| (_tree$nodesRef$curren = tree.nodesRef.current.find((node) => node.id === parentId)) == null \|\| (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;
3362	if (parentFloating) parentFloating.style.pointerEvents = "";
3363	body.style.pointerEvents = "none";
3364	ref.style.pointerEvents = "auto";
3365	floatingEl.style.pointerEvents = "auto";
3366	return () => {
3367	body.style.pointerEvents = "";
3368	ref.style.pointerEvents = "";
3369	floatingEl.style.pointerEvents = "";
3370	};
3371	}
3372	}
3373	}, [
3374	enabled,
3375	open,
3376	parentId,
3377	elements,
3378	tree,
3379	handleCloseRef,
3380	isHoverOpen
3381	]);
3382	index$1(() => {
3383	if (!open) {
3384	pointerTypeRef.current = void 0;
3385	restTimeoutPendingRef.current = false;
3386	cleanupMouseMoveHandler();
3387	clearPointerEvents();
3388	}
3389	}, [
3390	open,
3391	cleanupMouseMoveHandler,
3392	clearPointerEvents
3393	]);
3394	react$1.useEffect(() => {
3395	return () => {
3396	cleanupMouseMoveHandler();
3397	clearTimeoutIfSet(timeoutRef);
3398	clearTimeoutIfSet(restTimeoutRef);
3399	clearPointerEvents();
3400	};
3401	}, [
3402	enabled,
3403	elements.domReference,
3404	cleanupMouseMoveHandler,
3405	clearPointerEvents
3406	]);
3407	const reference = react$1.useMemo(() => {
3408	function setPointerRef(event) {
3409	pointerTypeRef.current = event.pointerType;
3410	}
3411	return {
3412	onPointerDown: setPointerRef,
3413	onPointerEnter: setPointerRef,
3414	onMouseMove(event) {
3415	const { nativeEvent } = event;
3416	function handleMouseMove() {
3417	if (!blockMouseMoveRef.current && !openRef.current) onOpenChange(true, nativeEvent, "hover");
3418	}
3419	if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) return;
3420	if (open \|\| getRestMs(restMsRef.current) === 0) return;
3421	if (restTimeoutPendingRef.current && event.movementX 2 + event.movementY 2 < 2) return;
3422	clearTimeoutIfSet(restTimeoutRef);
3423	if (pointerTypeRef.current === "touch") handleMouseMove();
3424	else {
3425	restTimeoutPendingRef.current = true;
3426	restTimeoutRef.current = window.setTimeout(handleMouseMove, getRestMs(restMsRef.current));
3427	}
3428	}
3429	};
3430	}, [
3431	mouseOnly,
3432	onOpenChange,
3433	open,
3434	openRef,
3435	restMsRef
3436	]);
3437	return react$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
3438	}
3439	var HIDDEN_STYLES = {
3440	border: 0,
3441	clip: "rect(0 0 0 0)",
3442	height: "1px",
3443	margin: "-1px",
3444	overflow: "hidden",
3445	padding: 0,
3446	position: "fixed",
3447	whiteSpace: "nowrap",
3448	width: "1px",
3449	top: 0,
3450	left: 0
3451	};
3452	var FocusGuard = /#__PURE__/ react$1.forwardRef(function FocusGuard(props, ref) {
3453	const [role, setRole] = react$1.useState();
3454	index$1(() => {
3455	if (isSafari()) setRole("button");
3456	}, []);
3457	const restProps = {
3458	ref,
3459	tabIndex: 0,
3460	role,
3461	"aria-hidden": role ? void 0 : true,
3462	[createAttribute("focus-guard")]: "",
3463	style: HIDDEN_STYLES
3464	};
3465	return /#__PURE__/ (0, import_jsx_runtime.jsx)("span", {
3466	...props,
3467	...restProps
3468	});
3469	});
3470	var HIDDEN_OWNER_STYLES = {
3471	clipPath: "inset(50%)",
3472	position: "fixed",
3473	top: 0,
3474	left: 0
3475	};
3476	var PortalContext = /#__PURE__/ react$1.createContext(null);
3477	var attr = /#__PURE__/ createAttribute("portal");
3478	/**
3479	* @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode
3480	*/
3481	function useFloatingPortalNode(props) {
3482	if (props === void 0) props = {};
3483	const { id, root } = props;
3484	const uniqueId = useId();
3485	const portalContext = usePortalContext();
3486	const [portalNode, setPortalNode] = react$1.useState(null);
3487	const portalNodeRef = react$1.useRef(null);
3488	index$1(() => {
3489	return () => {
3490	portalNode?.remove();
3491	queueMicrotask(() => {
3492	portalNodeRef.current = null;
3493	});
3494	};
3495	}, [portalNode]);
3496	index$1(() => {
3497	if (!uniqueId) return;
3498	if (portalNodeRef.current) return;
3499	const existingIdRoot = id ? document.getElementById(id) : null;
3500	if (!existingIdRoot) return;
3501	const subRoot = document.createElement("div");
3502	subRoot.id = uniqueId;
3503	subRoot.setAttribute(attr, "");
3504	existingIdRoot.appendChild(subRoot);
3505	portalNodeRef.current = subRoot;
3506	setPortalNode(subRoot);
3507	}, [id, uniqueId]);
3508	index$1(() => {
3509	if (root === null) return;
3510	if (!uniqueId) return;
3511	if (portalNodeRef.current) return;
3512	let container = root \|\| (portalContext == null ? void 0 : portalContext.portalNode);
3513	if (container && !isNode(container)) container = container.current;
3514	container = container \|\| document.body;
3515	let idWrapper = null;
3516	if (id) {
3517	idWrapper = document.createElement("div");
3518	idWrapper.id = id;
3519	container.appendChild(idWrapper);
3520	}
3521	const subRoot = document.createElement("div");
3522	subRoot.id = uniqueId;
3523	subRoot.setAttribute(attr, "");
3524	container = idWrapper \|\| container;
3525	container.appendChild(subRoot);
3526	portalNodeRef.current = subRoot;
3527	setPortalNode(subRoot);
3528	}, [
3529	id,
3530	root,
3531	uniqueId,
3532	portalContext
3533	]);
3534	return portalNode;
3535	}
3536	/**
3537	* Portals the floating element into a given container element — by default,
3538	* outside of the app root and into the body.
3539	* This is necessary to ensure the floating element can appear outside any
3540	* potential parent containers that cause clipping (such as `overflow: hidden`),
3541	* while retaining its location in the React tree.
3542	* @see https://floating-ui.com/docs/FloatingPortal
3543	*/
3544	function FloatingPortal(props) {
3545	const { children, id, root, preserveTabOrder = true } = props;
3546	const portalNode = useFloatingPortalNode({
3547	id,
3548	root
3549	});
3550	const [focusManagerState, setFocusManagerState] = react$1.useState(null);
3551	const beforeOutsideRef = react$1.useRef(null);
3552	const afterOutsideRef = react$1.useRef(null);
3553	const beforeInsideRef = react$1.useRef(null);
3554	const afterInsideRef = react$1.useRef(null);
3555	const modal = focusManagerState == null ? void 0 : focusManagerState.modal;
3556	const open = focusManagerState == null ? void 0 : focusManagerState.open;
3557	const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && preserveTabOrder && !!(root \|\| portalNode);
3558	react$1.useEffect(() => {
3559	if (!portalNode \|\| !preserveTabOrder \|\| modal) return;
3560	function onFocus(event) {
3561	if (portalNode && isOutsideEvent(event)) (event.type === "focusin" ? enableFocusInside : disableFocusInside)(portalNode);
3562	}
3563	portalNode.addEventListener("focusin", onFocus, true);
3564	portalNode.addEventListener("focusout", onFocus, true);
3565	return () => {
3566	portalNode.removeEventListener("focusin", onFocus, true);
3567	portalNode.removeEventListener("focusout", onFocus, true);
3568	};
3569	}, [
3570	portalNode,
3571	preserveTabOrder,
3572	modal
3573	]);
3574	react$1.useEffect(() => {
3575	if (!portalNode) return;
3576	if (open) return;
3577	enableFocusInside(portalNode);
3578	}, [open, portalNode]);
3579	return /#__PURE__/ (0, import_jsx_runtime.jsxs)(PortalContext.Provider, {
3580	value: react$1.useMemo(() => ({
3581	preserveTabOrder,
3582	beforeOutsideRef,
3583	afterOutsideRef,
3584	beforeInsideRef,
3585	afterInsideRef,
3586	portalNode,
3587	setFocusManagerState
3588	}), [preserveTabOrder, portalNode]),
3589	children: [
3590	shouldRenderGuards && portalNode && /#__PURE__/ (0, import_jsx_runtime.jsx)(FocusGuard, {
3591	"data-type": "outside",
3592	ref: beforeOutsideRef,
3593	onFocus: (event) => {
3594	if (isOutsideEvent(event, portalNode)) {
3595	var _beforeInsideRef$curr;
3596	(_beforeInsideRef$curr = beforeInsideRef.current) == null \|\| _beforeInsideRef$curr.focus();
3597	} else getPreviousTabbable(focusManagerState ? focusManagerState.domReference : null)?.focus();
3598	}
3599	}),
3600	shouldRenderGuards && portalNode && /#__PURE__/ (0, import_jsx_runtime.jsx)("span", {
3601	"aria-owns": portalNode.id,
3602	style: HIDDEN_OWNER_STYLES
3603	}),
3604	portalNode && /#__PURE__/ react_dom.createPortal(children, portalNode),
3605	shouldRenderGuards && portalNode && /#__PURE__/ (0, import_jsx_runtime.jsx)(FocusGuard, {
3606	"data-type": "outside",
3607	ref: afterOutsideRef,
3608	onFocus: (event) => {
3609	if (isOutsideEvent(event, portalNode)) {
3610	var _afterInsideRef$curre;
3611	(_afterInsideRef$curre = afterInsideRef.current) == null \|\| _afterInsideRef$curre.focus();
3612	} else {
3613	getNextTabbable(focusManagerState ? focusManagerState.domReference : null)?.focus();
3614	focusManagerState != null && focusManagerState.closeOnFocusOut && focusManagerState?.onOpenChange(false, event.nativeEvent, "focus-out");
3615	}
3616	}
3617	})
3618	]
3619	});
3620	}
3621	var usePortalContext = () => react$1.useContext(PortalContext);
3622	function useFloatingRootContext(options) {
3623	const { open = false, onOpenChange: onOpenChangeProp, elements: elementsProp } = options;
3624	const floatingId = useId();
3625	const dataRef = react$1.useRef({});
3626	const [events] = react$1.useState(() => createEventEmitter());
3627	const nested = useFloatingParentNodeId() != null;
3628	{
3629	const optionDomReference = elementsProp.reference;
3630	if (optionDomReference && !isElement(optionDomReference)) error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
3631	}
3632	const [positionReference, setPositionReference] = react$1.useState(elementsProp.reference);
3633	const onOpenChange = useEffectEvent((open, event, reason) => {
3634	dataRef.current.openEvent = open ? event : void 0;
3635	events.emit("openchange", {
3636	open,
3637	event,
3638	reason,
3639	nested
3640	});
3641	onOpenChangeProp?.(open, event, reason);
3642	});
3643	const refs = react$1.useMemo(() => ({ setPositionReference }), []);
3644	const elements = react$1.useMemo(() => ({
3645	reference: positionReference \|\| elementsProp.reference \|\| null,
3646	floating: elementsProp.floating \|\| null,
3647	domReference: elementsProp.reference
3648	}), [
3649	positionReference,
3650	elementsProp.reference,
3651	elementsProp.floating
3652	]);
3653	return react$1.useMemo(() => ({
3654	dataRef,
3655	open,
3656	onOpenChange,
3657	elements,
3658	events,
3659	floatingId,
3660	refs
3661	}), [
3662	open,
3663	onOpenChange,
3664	elements,
3665	events,
3666	floatingId,
3667	refs
3668	]);
3669	}
3670	/**
3671	* Provides data to position a floating element and context to add interactions.
3672	* @see https://floating-ui.com/docs/useFloating
3673	*/
3674	function useFloating(options) {
3675	if (options === void 0) options = {};
3676	const { nodeId } = options;
3677	const internalRootContext = useFloatingRootContext({
3678	...options,
3679	elements: {
3680	reference: null,
3681	floating: null,
3682	...options.elements
3683	}
3684	});
3685	const rootContext = options.rootContext \|\| internalRootContext;
3686	const computedElements = rootContext.elements;
3687	const [_domReference, setDomReference] = react$1.useState(null);
3688	const [positionReference, _setPositionReference] = react$1.useState(null);
3689	const domReference = (computedElements == null ? void 0 : computedElements.domReference) \|\| _domReference;
3690	const domReferenceRef = react$1.useRef(null);
3691	const tree = useFloatingTree();
3692	index$1(() => {
3693	if (domReference) domReferenceRef.current = domReference;
3694	}, [domReference]);
3695	const position = useFloating$1({
3696	...options,
3697	elements: {
3698	...computedElements,
3699	...positionReference && { reference: positionReference }
3700	}
3701	});
3702	const setPositionReference = react$1.useCallback((node) => {
3703	const computedPositionReference = isElement(node) ? {
3704	getBoundingClientRect: () => node.getBoundingClientRect(),
3705	getClientRects: () => node.getClientRects(),
3706	contextElement: node
3707	} : node;
3708	_setPositionReference(computedPositionReference);
3709	position.refs.setReference(computedPositionReference);
3710	}, [position.refs]);
3711	const setReference = react$1.useCallback((node) => {
3712	if (isElement(node) \|\| node === null) {
3713	domReferenceRef.current = node;
3714	setDomReference(node);
3715	}
3716	if (isElement(position.refs.reference.current) \|\| position.refs.reference.current === null \|\| node !== null && !isElement(node)) position.refs.setReference(node);
3717	}, [position.refs]);
3718	const refs = react$1.useMemo(() => ({
3719	...position.refs,
3720	setReference,
3721	setPositionReference,
3722	domReference: domReferenceRef
3723	}), [
3724	position.refs,
3725	setReference,
3726	setPositionReference
3727	]);
3728	const elements = react$1.useMemo(() => ({
3729	...position.elements,
3730	domReference
3731	}), [position.elements, domReference]);
3732	const context = react$1.useMemo(() => ({
3733	...position,
3734	...rootContext,
3735	refs,
3736	elements,
3737	nodeId
3738	}), [
3739	position,
3740	refs,
3741	elements,
3742	nodeId,
3743	rootContext
3744	]);
3745	index$1(() => {
3746	rootContext.dataRef.current.floatingContext = context;
3747	const node = tree == null ? void 0 : tree.nodesRef.current.find((node) => node.id === nodeId);
3748	if (node) node.context = context;
3749	});
3750	return react$1.useMemo(() => ({
3751	...position,
3752	context,
3753	refs,
3754	elements
3755	}), [
3756	position,
3757	refs,
3758	elements,
3759	context
3760	]);
3761	}
3762	function mergeProps(userProps, propsList, elementKey) {
3763	const map = /* @__PURE__ */ new Map();
3764	const isItem = elementKey === "item";
3765	let domUserProps = userProps;
3766	if (isItem && userProps) {
3767	const { [ACTIVE_KEY]: _, [SELECTED_KEY]: __, ...validProps } = userProps;
3768	domUserProps = validProps;
3769	}
3770	return {
3771	...elementKey === "floating" && {
3772	tabIndex: -1,
3773	[FOCUSABLE_ATTRIBUTE]: ""
3774	},
3775	...domUserProps,
3776	...propsList.map((value) => {
3777	const propsOrGetProps = value ? value[elementKey] : null;
3778	if (typeof propsOrGetProps === "function") return userProps ? propsOrGetProps(userProps) : null;
3779	return propsOrGetProps;
3780	}).concat(userProps).reduce((acc, props) => {
3781	if (!props) return acc;
3782	Object.entries(props).forEach((_ref) => {
3783	let [key, value] = _ref;
3784	if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) return;
3785	if (key.indexOf("on") === 0) {
3786	if (!map.has(key)) map.set(key, []);
3787	if (typeof value === "function") {
3788	var _map$get;
3789	(_map$get = map.get(key)) == null \|\| _map$get.push(value);
3790	acc[key] = function() {
3791	var _map$get2;
3792	for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
3793	return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
3794	};
3795	}
3796	} else acc[key] = value;
3797	});
3798	return acc;
3799	}, {})
3800	};
3801	}
3802	/**
3803	* Merges an array of interaction hooks' props into prop getters, allowing
3804	* event handler functions to be composed together without overwriting one
3805	* another.
3806	* @see https://floating-ui.com/docs/useInteractions
3807	*/
3808	function useInteractions(propsList) {
3809	if (propsList === void 0) propsList = [];
3810	const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
3811	const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
3812	const itemDeps = propsList.map((key) => key == null ? void 0 : key.item);
3813	const getReferenceProps = react$1.useCallback((userProps) => mergeProps(userProps, propsList, "reference"), referenceDeps);
3814	const getFloatingProps = react$1.useCallback((userProps) => mergeProps(userProps, propsList, "floating"), floatingDeps);
3815	const getItemProps = react$1.useCallback((userProps) => mergeProps(userProps, propsList, "item"), itemDeps);
3816	return react$1.useMemo(() => ({
3817	getReferenceProps,
3818	getFloatingProps,
3819	getItemProps
3820	}), [
3821	getReferenceProps,
3822	getFloatingProps,
3823	getItemProps
3824	]);
3825	}
3826
3827	//#endregion
3828	//#region packages/packages/core/editor-canvas/src/hooks/use-floating-on-element.ts
3829	function useFloatingOnElement({ element, isSelected }) {
3830	const [isOpen, setIsOpen] = (0, react.useState)(false);
3831	const sizeModifier = 2;
3832	const { refs, floatingStyles, context } = useFloating({
3833	open: isOpen \|\| isSelected,
3834	onOpenChange: setIsOpen,
3835	whileElementsMounted: autoUpdate,
3836	middleware: [size(() => {
3837	return { apply({ elements, rects }) {
3838	Object.assign(elements.floating.style, {
3839	width: `${rects.reference.width + sizeModifier}px`,
3840	height: `${rects.reference.height + sizeModifier}px`
3841	});
3842	} };
3843	}), offset(({ rects }) => -rects.reference.height / 2 - rects.floating.height / 2)]
3844	});
3845	(0, react.useEffect)(() => {
3846	refs.setReference(element);
3847	}, [element, refs]);
3848	return {
3849	isVisible: isOpen \|\| isSelected,
3850	context,
3851	floating: {
3852	setRef: refs.setFloating,
3853	ref: refs.floating,
3854	styles: floatingStyles
3855	}
3856	};
3857	}
3858
3859	//#endregion
3860	//#region packages/packages/core/editor-canvas/src/hooks/use-bind-react-props-to-element.ts
3861	function useBindReactPropsToElement(element, getProps) {
3862	(0, react.useEffect)(() => {
3863	const el = element;
3864	const { events, attrs } = groupProps(getProps());
3865	events.forEach(([eventName, listener]) => el.addEventListener(eventName, listener));
3866	attrs.forEach(([attrName, attrValue]) => el.setAttribute(attrName, attrValue));
3867	return () => {
3868	events.forEach(([eventName, listener]) => el.removeEventListener(eventName, listener));
3869	attrs.forEach(([attrName]) => el.removeAttribute(attrName));
3870	};
3871	}, [getProps, element]);
3872	}
3873	function groupProps(props) {
3874	const eventRegex = /^on(?=[A-Z])/;
3875	return Object.entries(props).reduce((acc, [propName, propValue]) => {
3876	if (!eventRegex.test(propName)) {
3877	acc.attrs.push([propName, propValue]);
3878	return acc;
3879	}
3880	const eventName = propName.replace(eventRegex, "").toLowerCase();
3881	const listener = propValue;
3882	acc.events.push([eventName, listener]);
3883	return acc;
3884	}, {
3885	events: [],
3886	attrs: []
3887	});
3888	}
3889
3890	//#endregion
3891	//#region packages/packages/core/editor-canvas/src/hooks/use-has-overlapping.ts
3892	var possibleOverlappingSelectors = [".e-off-canvas"];
3893	var useHasOverlapping = () => {
3894	const preview = window.elementor?.$preview?.[0];
3895	if (!preview) return false;
3896	return possibleOverlappingSelectors.map((selector) => Array.from(preview?.contentWindow?.document.body.querySelectorAll(selector) ?? [])).flat().some((elem) => elem.checkVisibility({
3897	opacityProperty: true,
3898	visibilityProperty: true,
3899	contentVisibilityAuto: true
3900	}));
3901	};
3902
3903	//#endregion
3904	//#region packages/packages/core/editor-canvas/src/utils/outline-offset-utils.ts
3905	var THIN_ELEMENT_MAX_HEIGHT_PX = 1;
3906	var SMALLER_OUTLINE_OFFSET_WIDGET_TYPES = /* @__PURE__ */ new Set(["e-form-input"]);
3907	function shouldUseSmallerOutlineOffset(element, widgetType) {
3908	if (element.offsetHeight <= 1) return true;
3909	return widgetType !== void 0 && SMALLER_OUTLINE_OFFSET_WIDGET_TYPES.has(widgetType);
3910	}
3911
3912	//#endregion
3913	//#region packages/packages/core/editor-canvas/src/components/outline-overlay.tsx
3914	var CANVAS_WRAPPER_ID = "elementor-preview-responsive-wrapper";
3915	var OverlayBox = (0, _elementor_ui.styled)(_elementor_ui.Box, { shouldForwardProp: (prop) => prop !== "isSelected" && prop !== "isSmallerOffset" && prop !== "isGlobal" })(({ theme, isSelected, isSmallerOffset, isGlobal }) => ({
3916	outline: `${isSelected ? "2px" : "1px"} solid ${isGlobal ? theme.palette.global.main : theme.palette.primary.light}`,
3917	outlineOffset: isSelected && !isSmallerOffset ? "-2px" : "-1px",
3918	pointerEvents: "none"
3919	}));
3920	var OutlineOverlay = ({ element, isSelected, id, isGlobal = false, widgetType }) => {
3921	const { context, floating, isVisible } = useFloatingOnElement({
3922	element,
3923	isSelected
3924	});
3925	const { getFloatingProps, getReferenceProps } = useInteractions([useHover(context)]);
3926	const hasOverlapping = useHasOverlapping();
3927	useBindReactPropsToElement(element, getReferenceProps);
3928	const isSmallerOffset = shouldUseSmallerOutlineOffset(element, widgetType);
3929	return isVisible && !hasOverlapping && /* @__PURE__ / react.createElement(FloatingPortal, { id: "elementor-preview-responsive-wrapper" }, / @__PURE__ */ react.createElement(OverlayBox, {
3930	ref: floating.setRef,
3931	isSelected,
3932	isGlobal,
3933	style: floating.styles,
3934	"data-element-overlay": id,
3935	role: "presentation",
3936	isSmallerOffset,
3937	...getFloatingProps()
3938	}));
3939	};
3940
3941	//#endregion
3942	//#region packages/packages/core/editor-canvas/src/components/grid-outline/cell.tsx
3943	var FALLBACK_COLOR$1 = "rgba(0, 0, 0, 0.12)";
3944	function Cell({ x, y, width, height, color }) {
3945	return /* @__PURE__ */ react.createElement("rect", {
3946	x,
3947	y,
3948	width,
3949	height,
3950	fill: "none",
3951	stroke: color \|\| FALLBACK_COLOR$1,
3952	strokeWidth: 1,
3953	strokeDasharray: "2 2",
3954	vectorEffect: "non-scaling-stroke"
3955	});
3956	}
3957
3958	//#endregion
3959	//#region packages/packages/core/editor-canvas/src/components/grid-outline/first-empty-cell.tsx
3960	var GLYPH_SIZE = 19;
3961	function FirstEmptyCell({ rect, color }) {
3962	const size = Math.min(GLYPH_SIZE, rect.width, rect.height);
3963	if (size <= 0) return null;
3964	const centerX = rect.x + rect.width / 2;
3965	const centerY = rect.y + rect.height / 2;
3966	return /* @__PURE__ */ react.createElement("i", {
3967	className: "eicon-plus",
3968	"aria-hidden": "true",
3969	style: {
3970	position: "absolute",
3971	left: centerX,
3972	top: centerY,
3973	transform: "translate(-50%, -50%)",
3974	fontSize: size,
3975	color,
3976	lineHeight: 1,
3977	pointerEvents: "none"
3978	}
3979	});
3980	}
3981
3982	//#endregion
3983	//#region packages/packages/core/editor-canvas/src/components/grid-outline/line.tsx
3984	var FALLBACK_COLOR = "rgba(0, 0, 0, 0.12)";
3985	function Line({ x1, y1, x2, y2, color }) {
3986	return /* @__PURE__ */ react.createElement("line", {
3987	x1,
3988	y1,
3989	x2,
3990	y2,
3991	stroke: color \|\| FALLBACK_COLOR,
3992	strokeWidth: 1,
3993	strokeDasharray: "2 2",
3994	vectorEffect: "non-scaling-stroke"
3995	});
3996	}
3997
3998	//#endregion
3999	//#region packages/packages/core/editor-canvas/src/components/grid-outline/grid-outline.tsx
4000	var renderCells = (cells, color) => cells.map((cell, i) => /* @__PURE__ */ react.createElement(Cell, {
4001	key: i,
4002	x: snapToHalfPixel(cell.x),
4003	y: snapToHalfPixel(cell.y),
4004	width: Math.round(cell.width),
4005	height: Math.round(cell.height),
4006	color
4007	}));
4008	var renderLines = (tracks, width, height) => {
4009	const { vertical, horizontal } = computeGridLines(tracks, width, height);
4010	return [...vertical.map((line, i) => /* @__PURE__ */ react.createElement(Line, {
4011	key: `v${i}`,
4012	x1: snapToHalfPixel(line.x1),
4013	y1: Math.round(line.y1),
4014	x2: snapToHalfPixel(line.x2),
4015	y2: Math.round(line.y2),
4016	color: tracks.borderColor
4017	})), ...horizontal.map((line, i) => /* @__PURE__ */ react.createElement(Line, {
4018	key: `h${i}`,
4019	x1: Math.round(line.x1),
4020	y1: snapToHalfPixel(line.y1),
4021	x2: Math.round(line.x2),
4022	y2: snapToHalfPixel(line.y2),
4023	color: tracks.borderColor
4024	}))];
4025	};
4026	var isDragActiveFromDom = (element) => {
4027	return Boolean(element?.querySelector(".e-dragging-over, .elementor-dragging-on-child, .elementor-draggable-over, .elementor-widget-placeholder, .elementor-sortable-placeholder"));
4028	};
4029	function GridOutline({ element, tracks, width, height }) {
4030	const cells = (0, react.useMemo)(() => computeCellRects(tracks, width, height), [
4031	tracks,
4032	width,
4033	height
4034	]);
4035	const hasGap = tracks.columnGap > 0 \|\| tracks.rowGap > 0;
4036	const firstEmpty = (0, react.useMemo)(() => findFirstEmptyCell(element, tracks.columns.length, tracks.rows.length), [element, tracks]);
4037	const emptyCellRect = firstEmpty && tracks.columns.length > 0 ? cells[firstEmpty.row * tracks.columns.length + firstEmpty.col] : null;
4038	return /* @__PURE__ / react.createElement(react.Fragment, null, / @__PURE__ */ react.createElement("svg", {
4039	width,
4040	height,
4041	style: {
4042	position: "absolute",
4043	inset: 0,
4044	overflow: "visible"
4045	},
4046	xmlns: "http://www.w3.org/2000/svg"
4047	}, hasGap ? renderCells(cells, tracks.borderColor) : renderLines(tracks, width, height)), emptyCellRect && !isDragActiveFromDom(element) && /* @__PURE__ */ react.createElement(FirstEmptyCell, {
4048	rect: emptyCellRect,
4049	color: tracks.borderColor
4050	}));
4051	}
4052
4053	//#endregion
4054	//#region packages/packages/core/editor-canvas/src/components/grid-outline/grid-outline-overlay.tsx
4055	var GridOutlineOverlay = ({ element, id, isSelected }) => {
4056	const enabled = (0, _elementor_editor_elements.useElementEditorSettings)(id)?.grid_outline;
4057	const rect = useElementRect(element);
4058	const tracks = useGridTracks(element, rect);
4059	const { floating } = useFloatingOnElement({
4060	element,
4061	isSelected
4062	});
4063	if (enabled === false) return null;
4064	if (tracks.columns.length === 0 && tracks.rows.length === 0) return null;
4065	return /* @__PURE__ / react.createElement(FloatingPortal, { id: CANVAS_WRAPPER_ID }, / @__PURE__ */ react.createElement(_elementor_ui.Box, {
4066	ref: floating.setRef,
4067	style: {
4068	...floating.styles,
4069	pointerEvents: "none"
4070	},
4071	"data-grid-outline": id,
4072	role: "presentation"
4073	}, /* @__PURE__ */ react.createElement(GridOutline, {
4074	element,
4075	tracks,
4076	width: rect.width,
4077	height: rect.height
4078	})));
4079	};
4080
4081	//#endregion
4082	//#region packages/packages/core/editor-canvas/src/components/elements-overlays.tsx
4083	var hasGridStyleDisplay = (element) => {
4084	return element.computedStyleMap().get("display")?.toString() === "grid";
4085	};
4086	var ELEMENTS_DATA_ATTR = "atomic";
4087	var overlayRegistry = [
4088	{
4089	component: OutlineOverlay,
4090	shouldRender: () => true
4091	},
4092	{
4093	component: GridEmptyCellPositioner,
4094	shouldRender: ({ element }) => hasGridStyleDisplay(element)
4095	},
4096	{
4097	component: GridOutlineOverlay,
4098	shouldRender: ({ isSelected, element }) => isSelected && hasGridStyleDisplay(element)
4099	}
4100	];
4101	function ElementsOverlays() {
4102	const selected = (0, _elementor_editor_elements.useSelectedElement)();
4103	const elements = useElementsDom();
4104	const isEditMode = (0, _elementor_editor_v1_adapters.useEditMode)() === "edit";
4105	const isKitRouteActive = (0, _elementor_editor_v1_adapters.__privateUseIsRouteActive)("panel/global");
4106	if (!(isEditMode && !isKitRouteActive)) return null;
4107	return elements.map(({ id, domElement, isGlobal, widgetType }) => {
4108	const isSelected = selected.element?.id === id;
4109	return overlayRegistry.map(({ shouldRender, component: Overlay }, index) => shouldRender({
4110	id,
4111	element: domElement,
4112	isSelected,
4113	widgetType
4114	}) && /* @__PURE__ */ react.createElement(Overlay, {
4115	key: `${id}-${index}`,
4116	id,
4117	element: domElement,
4118	isSelected,
4119	isGlobal,
4120	widgetType
4121	}));
4122	});
4123	}
4124	function useElementsDom() {
4125	return (0, _elementor_editor_v1_adapters.__privateUseListenTo)([(0, _elementor_editor_v1_adapters.windowEvent)("elementor/editor/element-rendered"), (0, _elementor_editor_v1_adapters.windowEvent)("elementor/editor/element-destroyed")], () => {
4126	return (0, _elementor_editor_elements.getElements)().filter((el) => isV4Element(el.view?.el?.dataset)).map((element) => ({
4127	id: element.id,
4128	domElement: element.view?.getDomElement?.()?.get?.(0),
4129	isGlobal: element.model.get("isGlobal") ?? false,
4130	widgetType: element.model.get("widgetType")
4131	})).filter((item) => !!item.domElement);
4132	});
4133	}
4134	function isV4Element(dataset) {
4135	if (!dataset) return false;
4136	return ELEMENTS_DATA_ATTR in dataset \|\| "eType" in dataset;
4137	}
4138
4139	//#endregion
4140	//#region packages/packages/core/editor-canvas/src/hooks/use-on-mount.ts
4141	function useOnMount(cb) {
4142	const mounted = (0, react.useRef)(false);
4143	(0, react.useEffect)(() => {
4144	if (!mounted.current) {
4145	mounted.current = true;
4146	cb();
4147	}
4148	}, []);
4149	}
4150
4151	//#endregion
4152	//#region packages/packages/core/editor-canvas/src/hooks/use-interactions-items.ts
4153	function useInteractionsItems() {
4154	const [interactionItems, setInteractionItems] = (0, react.useState)({});
4155	const providerAndSubscribers = (0, react.useMemo)(() => {
4156	try {
4157	return _elementor_editor_interactions.interactionsRepository.getProviders().map((provider) => {
4158	return {
4159	provider,
4160	subscriber: createProviderSubscriber$1({
4161	provider,
4162	setInteractionItems
4163	})
4164	};
4165	});
4166	} catch {
4167	return [];
4168	}
4169	}, []);
4170	(0, react.useEffect)(() => {
4171	if (providerAndSubscribers.length === 0) return;
4172	const unsubscribes = providerAndSubscribers.map(({ provider, subscriber }) => {
4173	const safeSubscriber = () => {
4174	try {
4175	subscriber();
4176	} catch {}
4177	};
4178	return provider.subscribe(safeSubscriber);
4179	});
4180	return () => {
4181	unsubscribes.forEach((unsubscribe) => unsubscribe());
4182	};
4183	}, [providerAndSubscribers]);
4184	useOnMount(() => {
4185	if (providerAndSubscribers.length === 0) return;
4186	(0, _elementor_editor_v1_adapters.registerDataHook)("after", "editor/documents/attach-preview", async () => {
4187	providerAndSubscribers.forEach(({ subscriber }) => {
4188	try {
4189	subscriber();
4190	} catch {}
4191	});
4192	});
4193	});
4194	return (0, react.useMemo)(() => {
4195	return Object.values(interactionItems).sort(sortByProviderPriority).flatMap(({ items }) => items);
4196	}, [interactionItems]);
4197	}
4198	function sortByProviderPriority({ provider: providerA }, { provider: providerB }) {
4199	return providerA.priority - providerB.priority;
4200	}
4201	function createProviderSubscriber$1({ provider, setInteractionItems }) {
4202	return () => {
4203	try {
4204	const items = provider.actions.all();
4205	const providerKey = provider.getKey();
4206	setInteractionItems((prev) => ({
4207	...prev,
4208	[providerKey]: {
4209	provider,
4210	items
4211	}
4212	}));
4213	} catch {}
4214	};
4215	}
4216	__name(createProviderSubscriber$1, "createProviderSubscriber");
4217
4218	//#endregion
4219	//#region packages/packages/core/editor-canvas/src/components/interactions-renderer.tsx
4220	function InteractionsRenderer() {
4221	const container = usePortalContainer$1();
4222	const interactionItems = useInteractionsItems();
4223	if (!container) return null;
4224	const interactionsData = JSON.stringify(Array.isArray(interactionItems) ? interactionItems : []);
4225	return /* @__PURE__ / react.createElement(_elementor_ui.Portal, { container }, / @__PURE__ */ react.createElement("script", {
4226	type: "application/json",
4227	"data-e-interactions": "true",
4228	dangerouslySetInnerHTML: { __html: interactionsData }
4229	}));
4230	}
4231	function usePortalContainer$1() {
4232	return (0, _elementor_editor_v1_adapters.__privateUseListenTo)((0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview"), () => (0, _elementor_editor_v1_adapters.getCanvasIframeDocument)()?.head);
4233	}
4234	__name(usePortalContainer$1, "usePortalContainer");
4235
4236	//#endregion
4237	//#region packages/packages/core/editor-canvas/src/hooks/use-documents-css-links.ts
4238	var REMOVED_ATTR = "data-e-removed";
4239	var DOCUMENT_WRAPPER_ATTR = "data-elementor-id";
4240	var CSS_LINK_ID_PREFIX = "elementor-post-";
4241	var CSS_LINK_ID_SUFFIX = "-css";
4242	function useDocumentsCssLinks() {
4243	return (0, _elementor_editor_v1_adapters.__privateUseListenTo)((0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview"), () => {
4244	const iframeDocument = (0, _elementor_editor_v1_adapters.getCanvasIframeDocument)();
4245	if (!iframeDocument) return [];
4246	const relevantLinkIds = getDocumentsIdsInCanvas(iframeDocument).map((id) => `${CSS_LINK_ID_PREFIX}${id}${CSS_LINK_ID_SUFFIX}`);
4247	const links = getDocumentsCssLinks(iframeDocument).filter((link) => relevantLinkIds.includes(link.getAttribute("id") ?? ""));
4248	links.forEach((link) => {
4249	if (!link.hasAttribute(REMOVED_ATTR)) link.remove();
4250	});
4251	return links.map((link) => ({
4252	...getLinkAttrs(link),
4253	id: link.getAttribute("id") ?? "",
4254	[REMOVED_ATTR]: true
4255	}));
4256	});
4257	}
4258	function getDocumentsIdsInCanvas(document) {
4259	return [...document.body.querySelectorAll(`[${DOCUMENT_WRAPPER_ATTR}]`) ?? []].map((el) => el.getAttribute(DOCUMENT_WRAPPER_ATTR) \|\| "");
4260	}
4261	function getDocumentsCssLinks(document) {
4262	return [...document.head.querySelectorAll(`link[rel="stylesheet"][id^=${CSS_LINK_ID_PREFIX}][id$=${CSS_LINK_ID_SUFFIX}]`) ?? []];
4263	}
4264	function getLinkAttrs(el) {
4265	const entries = [...el.attributes].map((attr) => [attr.name, attr.value]);
4266	return Object.fromEntries(entries);
4267	}
4268
4269	//#endregion
4270	//#region packages/packages/core/editor-canvas/src/utils/abort-previous-runs.ts
4271	function abortPreviousRuns(cb) {
4272	let abortController = null;
4273	return (...args) => {
4274	if (abortController) abortController.abort();
4275	abortController = new AbortController();
4276	return cb(abortController, ...args);
4277	};
4278	}
4279
4280	//#endregion
4281	//#region packages/packages/core/editor-canvas/src/utils/pregenerated-links-removal.ts
4282	var removedProviderKeys = /* @__PURE__ */ new Set();
4283	function removeProviderPregeneratedLinks(providerKey, removePregeneratedLink) {
4284	if (removedProviderKeys.has(providerKey)) return;
4285	const iframeDocument = (0, _elementor_editor_v1_adapters.getCanvasIframeDocument)();
4286	if (!iframeDocument) return;
4287	iframeDocument.head.querySelectorAll("link[rel=\"stylesheet\"]").forEach((link) => {
4288	const { id, href, media } = link;
4289	if (removePregeneratedLink({
4290	id,
4291	href,
4292	media
4293	})) link.remove();
4294	});
4295	removedProviderKeys.add(providerKey);
4296	}
4297	function resetRemovedProviders() {
4298	removedProviderKeys.clear();
4299	}
4300
4301	//#endregion
4302	//#region packages/packages/core/editor-canvas/src/utils/signalized-process.ts
4303	function signalizedProcess(signal, steps = []) {
4304	return {
4305	then: (cb) => {
4306	steps.push(cb);
4307	return signalizedProcess(signal, steps);
4308	},
4309	execute: async () => {
4310	let lastResult;
4311	for (const step of steps) {
4312	if (signal.aborted) break;
4313	lastResult = await step(lastResult, signal);
4314	}
4315	}
4316	};
4317	}
4318
4319	//#endregion
4320	//#region packages/packages/core/editor-canvas/src/renderers/multi-props.ts
4321	var isMultiProps = (propValue) => {
4322	return !!propValue && typeof propValue === "object" && "$$multi-props" in propValue && propValue["$$multi-props"] === true;
4323	};
4324	var createMultiPropsValue = (props) => {
4325	return {
4326	"$$multi-props": true,
4327	value: props
4328	};
4329	};
4330	var getMultiPropsValue = (multiProps) => {
4331	return multiProps.value;
4332	};
4333
4334	//#endregion
4335	//#region packages/packages/core/editor-canvas/src/renderers/create-props-resolver.ts
4336	var TRANSFORM_DEPTH_LIMIT = 3;
4337	function createPropsResolver({ transformers, schema: initialSchema, onPropResolve }) {
4338	async function resolve({ props, schema, signal, renderContext }) {
4339	schema = schema ?? initialSchema;
4340	const promises = Promise.all(Object.entries(schema).map(async ([key, type]) => {
4341	const value = props[key] ?? type.default;
4342	const transformed = await transform({
4343	value,
4344	key,
4345	type,
4346	signal,
4347	renderContext
4348	});
4349	onPropResolve?.({
4350	key,
4351	value: transformed,
4352	propValue: value,
4353	propType: type
4354	});
4355	if (isMultiProps(transformed)) return getMultiPropsValue(transformed);
4356	return { [key]: transformed };
4357	}));
4358	return Object.assign({}, ...(await promises).filter(Boolean));
4359	}
4360	async function transform({ value, key, type, signal, depth = 0, renderContext }) {
4361	if (value === null \|\| value === void 0) return null;
4362	if (!(0, _elementor_editor_props.isTransformable)(value)) return value;
4363	if (depth > TRANSFORM_DEPTH_LIMIT) return null;
4364	if (value.disabled === true) return null;
4365	let transformablePropType = type;
4366	if (type.kind === "union") {
4367	transformablePropType = type.prop_types[value.$$type];
4368	if (!transformablePropType) return null;
4369	}
4370	transformablePropType = transformablePropType;
4371	if (value.$$type !== transformablePropType.key) return null;
4372	let resolvedValue = value.value;
4373	if (transformablePropType.kind === "object") resolvedValue = await resolve({
4374	props: resolvedValue,
4375	schema: transformablePropType.shape,
4376	signal,
4377	renderContext
4378	});
4379	if (transformablePropType.kind === "array") resolvedValue = await Promise.all(resolvedValue.map((item) => transform({
4380	value: item,
4381	key,
4382	type: transformablePropType.item_prop_type,
4383	depth,
4384	signal,
4385	renderContext
4386	})));
4387	const transformer = transformers.get(value.$$type);
4388	if (!transformer) return null;
4389	try {
4390	return transform({
4391	value: await transformer(resolvedValue, {
4392	key,
4393	signal,
4394	renderContext,
4395	propType: type
4396	}),
4397	key,
4398	type,
4399	signal,
4400	depth: depth + 1,
4401	renderContext
4402	});
4403	} catch {
4404	return null;
4405	}
4406	}
4407	return resolve;
4408	}
4409
4410	//#endregion
4411	//#region packages/packages/core/editor-canvas/src/renderers/enqueue-font-from-style-prop.ts
4412	var maybeEnqueueFontFromStyleProp = (propType, propValue, enqueue) => {
4413	if (!(0, _elementor_editor_props.isTransformable)(propValue) \|\| propValue.disabled) return;
4414	const propTypeUtil = (0, _elementor_editor_props.getPropSchemaFromCache)(propType.kind === "union" ? propValue.$$type : propType.key);
4415	if (!propTypeUtil \|\| !("getEnqueueFontFamily" in propTypeUtil) \|\| typeof propTypeUtil.getEnqueueFontFamily !== "function") return;
4416	const stored = propValue.value;
4417	if (typeof stored !== "string") return;
4418	const font = propTypeUtil.getEnqueueFontFamily(stored);
4419	if (font) enqueue(font);
4420	};
4421
4422	//#endregion
4423	//#region packages/packages/core/editor-canvas/src/transformers/create-transformers-registry.ts
4424	function createTransformersRegistry() {
4425	const transformers = {};
4426	let fallbackTransformer = null;
4427	return {
4428	register(type, transformer) {
4429	transformers[type] = transformer;
4430	return this;
4431	},
4432	registerFallback(transformer) {
4433	fallbackTransformer = transformer;
4434	return this;
4435	},
4436	get(type) {
4437	return transformers[type] ?? fallbackTransformer;
4438	},
4439	all() {
4440	return { ...transformers };
4441	}
4442	};
4443	}
4444	var stylesInheritanceTransformersRegistry = createTransformersRegistry();
4445
4446	//#endregion
4447	//#region packages/packages/core/editor-canvas/src/style-transformers-registry.ts
4448	var styleTransformersRegistry = createTransformersRegistry();
4449
4450	//#endregion
4451	//#region packages/packages/core/editor-canvas/src/hooks/use-style-prop-resolver.ts
4452	function useStylePropResolver() {
4453	return (0, react.useMemo)(() => {
4454	return createPropsResolver({
4455	transformers: styleTransformersRegistry,
4456	schema: (0, _elementor_editor_styles.getStylesSchema)(),
4457	onPropResolve: ({ propValue, propType }) => {
4458	maybeEnqueueFontFromStyleProp(propType, propValue, _elementor_editor_v1_adapters.enqueueFont);
4459	}
4460	});
4461	}, []);
4462	}
4463
4464	//#endregion
4465	//#region packages/packages/core/editor-canvas/src/renderers/errors.ts
4466	var UnknownStyleTypeError = (0, _elementor_utils.createError)({
4467	code: "unknown_style_type",
4468	message: "Unknown style type"
4469	});
4470	var UnknownStyleStateError = (0, _elementor_utils.createError)({
4471	code: "unknown_style_state",
4472	message: "Unknown style state"
4473	});
4474
4475	//#endregion
4476	//#region packages/packages/core/editor-canvas/src/renderers/create-styles-renderer.ts
4477	var SELECTORS_MAP = { class: "." };
4478	var DEFAULT_BREAKPOINT = "desktop";
4479	var DEFAULT_STATE = "normal";
4480	function getStyleUniqueKey(style) {
4481	const breakpoint = style.variants[0]?.meta?.breakpoint ?? DEFAULT_BREAKPOINT;
4482	const state = style.variants[0]?.meta?.state ?? DEFAULT_STATE;
4483	return `${style.id}-${breakpoint}-${state}`;
4484	}
4485	function createStylesRenderer({ resolve, breakpoints, selectorPrefix = "" }) {
4486	return async ({ styles, signal }) => {
4487	const seenKeys = /* @__PURE__ */ new Set();
4488	const stylesCssPromises = styles.filter((style) => {
4489	const key = getStyleUniqueKey(style);
4490	if (seenKeys.has(key)) return false;
4491	seenKeys.add(key);
4492	return true;
4493	}).map(async (style) => {
4494	const variantCssPromises = Object.values(style.variants).map(async (variant) => {
4495	const css = await propsToCss({
4496	props: variant.props,
4497	resolve,
4498	signal
4499	});
4500	const customCss = customCssToString(variant.custom_css);
4501	return createStyleWrapper().for(style.cssName, style.type).withPrefix(selectorPrefix).withState(variant.meta.state).withMediaQuery(variant.meta.breakpoint ? breakpoints[variant.meta.breakpoint] : null).wrap(css + customCss);
4502	});
4503	const variantsCss = await Promise.all(variantCssPromises);
4504	return {
4505	id: style.id,
4506	breakpoint: style?.variants[0]?.meta?.breakpoint \|\| "desktop",
4507	value: variantsCss.join(""),
4508	state: style?.variants[0]?.meta?.state \|\| null
4509	};
4510	});
4511	return await Promise.all(stylesCssPromises);
4512	};
4513	}
4514	function createStyleWrapper(value = "", wrapper) {
4515	return {
4516	for: (cssName, type) => {
4517	const symbol = SELECTORS_MAP[type];
4518	if (!symbol) throw new UnknownStyleTypeError({ context: { type } });
4519	return createStyleWrapper(`${value}${symbol}${cssName}`, wrapper);
4520	},
4521	withPrefix: (prefix) => createStyleWrapper([prefix, value].filter(Boolean).join(" "), wrapper),
4522	withState: (state) => {
4523	return createStyleWrapper((0, _elementor_editor_styles.getSelectorWithState)(value, state), wrapper);
4524	},
4525	withMediaQuery: (breakpoint) => {
4526	if (!breakpoint?.type) return createStyleWrapper(value, wrapper);
4527	const size = `${breakpoint.type}:${breakpoint.width}px`;
4528	return createStyleWrapper(value, (css) => `@media(${size}){${css}}`);
4529	},
4530	wrap: (css) => {
4531	const res = `${value}{${css}}`;
4532	if (!wrapper) return res;
4533	return wrapper(res);
4534	}
4535	};
4536	}
4537	async function propsToCss({ props, resolve, signal }) {
4538	const transformed = await resolve({
4539	props,
4540	signal
4541	});
4542	return Object.entries(transformed).reduce((acc, [propName, propValue]) => {
4543	if (propValue === null) return acc;
4544	acc.push(propName + ":" + propValue + ";");
4545	return acc;
4546	}, []).join("");
4547	}
4548	function customCssToString(customCss) {
4549	const decoded = (0, _elementor_utils.decodeString)(customCss?.raw \|\| "");
4550	if (!decoded.trim()) return "";
4551	return decoded + "\n";
4552	}
4553
4554	//#endregion
4555	//#region packages/packages/core/editor-canvas/src/hooks/use-style-renderer.ts
4556	var SELECTOR_PREFIX = ".elementor";
4557	function useStyleRenderer(resolve) {
4558	const breakpoints = (0, _elementor_editor_responsive.useBreakpointsMap)();
4559	return (0, react.useMemo)(() => {
4560	return createStylesRenderer({
4561	selectorPrefix: SELECTOR_PREFIX,
4562	breakpoints,
4563	resolve
4564	});
4565	}, [resolve, breakpoints]);
4566	}
4567
4568	//#endregion
4569	//#region packages/packages/core/editor-canvas/src/hooks/use-style-items.ts
4570	function useStyleItems() {
4571	const renderStyles = useStyleRenderer(useStylePropResolver());
4572	const breakpoints = (0, _elementor_editor_responsive.useBreakpoints)();
4573	const [styleItems, setStyleItems] = (0, react.useState)({});
4574	const styleItemsCacheRef = (0, react.useRef)(/* @__PURE__ */ new Map());
4575	const providerAndSubscribers = (0, react.useMemo)(() => {
4576	const createEmptyCache = () => {
4577	return {
4578	orderedIds: [],
4579	itemsById: /* @__PURE__ */ new Map()
4580	};
4581	};
4582	const getCache = (provider) => {
4583	const providerKey = safeGetKey(provider);
4584	if (!providerKey) return createEmptyCache();
4585	if (!styleItemsCacheRef.current.has(providerKey)) styleItemsCacheRef.current.set(providerKey, createEmptyCache());
4586	return styleItemsCacheRef.current.get(providerKey);
4587	};
4588	return _elementor_editor_styles_repository.stylesRepository.getProviders().map((provider) => ({
4589	provider,
4590	subscriber: createProviderSubscriber({
4591	provider,
4592	renderStyles,
4593	setStyleItems,
4594	getCache: () => getCache(provider)
4595	})
4596	}));
4597	}, [renderStyles]);
4598	(0, react.useEffect)(() => {
4599	const unsubscribes = providerAndSubscribers.map(({ provider, subscriber }) => provider.subscribe(subscriber));
4600	return () => {
4601	unsubscribes.forEach((unsubscribe) => unsubscribe());
4602	};
4603	}, [providerAndSubscribers]);
4604	useOnMount(() => {
4605	(0, _elementor_editor_v1_adapters.registerDataHook)("after", "editor/documents/attach-preview", async () => {
4606	resetRemovedProviders();
4607	const promises = providerAndSubscribers.map(async ({ subscriber }) => subscriber());
4608	await Promise.all(promises);
4609	});
4610	});
4611	const breakpointSorter = (0, react.useMemo)(() => createBreakpointSorter(breakpoints.map((breakpoint) => breakpoint.id)), [breakpoints]);
4612	return (0, react.useMemo)(() => Object.values(styleItems).sort(prioritySorter).flatMap(({ items }) => items).sort(stateSorter).sort(breakpointSorter), [styleItems, breakpointSorter]);
4613	}
4614	function prioritySorter({ provider: providerA }, { provider: providerB }) {
4615	return providerA.priority - providerB.priority;
4616	}
4617	function stateSorter({ state: stateA }, { state: stateB }) {
4618	if ((0, _elementor_editor_styles.isClassState)(stateA) && !(0, _elementor_editor_styles.isClassState)(stateB)) return -1;
4619	if (!(0, _elementor_editor_styles.isClassState)(stateA) && (0, _elementor_editor_styles.isClassState)(stateB)) return 1;
4620	return 0;
4621	}
4622	function createBreakpointSorter(breakpointsOrder) {
4623	return ({ breakpoint: breakpointA }, { breakpoint: breakpointB }) => breakpointsOrder.indexOf(breakpointA) - breakpointsOrder.indexOf(breakpointB);
4624	}
4625	function safeGetKey(provider) {
4626	try {
4627	return provider.getKey();
4628	} catch {
4629	return null;
4630	}
4631	}
4632	function createProviderSubscriber({ provider, renderStyles, setStyleItems, getCache }) {
4633	return abortPreviousRuns((abortController, previous, current) => signalizedProcess(abortController.signal).then((_, signal) => {
4634	const cache = getCache();
4635	const hasDiffInfo = current !== void 0 && previous !== void 0;
4636	const hasCache = cache.orderedIds.length > 0;
4637	if (hasCache && provider.isPregeneratedLink) removeProviderPregeneratedLinks(provider.getKey(), provider.isPregeneratedLink);
4638	if (hasDiffInfo && hasCache) return updateItems(cache, previous, current, signal);
4639	return createItems(cache, signal);
4640	}).then((items) => {
4641	setStyleItems((prev) => ({
4642	...prev,
4643	[provider.getKey()]: {
4644	provider,
4645	items
4646	}
4647	}));
4648	}).execute());
4649	async function updateItems(cache, previous, current, signal) {
4650	const changedIds = getChangedStyleIds(previous, current);
4651	cache.orderedIds = provider.actions.all().map((style) => style.id).reverse();
4652	if (changedIds.length > 0) return renderStyles({
4653	styles: breakToBreakpoints(changedIds.map((id) => provider.actions.get(id)).filter((style) => !!style).map((style) => ({
4654	...style,
4655	cssName: provider.actions.resolveCssName(style.id)
4656	}))),
4657	signal
4658	}).then((rendered) => {
4659	updateCacheItems(cache, changedIds, rendered);
4660	return getOrderedItems(cache);
4661	});
4662	return getOrderedItems(cache);
4663	}
4664	async function createItems(cache, signal) {
4665	const allStyles = provider.actions.all();
4666	return renderStyles({
4667	styles: breakToBreakpoints([...allStyles].reverse().map((style) => {
4668	return {
4669	...style,
4670	cssName: provider.actions.resolveCssName(style.id)
4671	};
4672	})),
4673	signal
4674	}).then((rendered) => {
4675	rebuildCache(cache, allStyles, rendered);
4676	return getOrderedItems(cache);
4677	});
4678	}
4679	function breakToBreakpoints(styles) {
4680	return Object.values(styles.reduce((acc, style) => {
4681	style.variants.forEach((variant) => {
4682	const breakpoint = variant.meta.breakpoint \|\| "desktop";
4683	if (!acc[style.id]) acc[style.id] = {};
4684	if (!acc[style.id][breakpoint]) acc[style.id][breakpoint] = {
4685	...style,
4686	variants: []
4687	};
4688	acc[style.id][breakpoint].variants.push(variant);
4689	});
4690	return acc;
4691	}, {})).flatMap((breakpointMap) => Object.values(breakpointMap));
4692	}
4693	}
4694	function getChangedStyleIds(previous, current) {
4695	const changedIds = [];
4696	for (const id of Object.keys(current)) {
4697	const currentStyle = current[id];
4698	const previousStyle = previous[id];
4699	if (!previousStyle \|\| currentStyle !== previousStyle) changedIds.push(id);
4700	}
4701	return changedIds;
4702	}
4703	function getOrderedItems(cache) {
4704	return cache.orderedIds.map((id) => cache.itemsById.get(id)).filter((items) => items !== void 0).flat();
4705	}
4706	function updateCacheItems(cache, changedIds, changedItems) {
4707	for (const id of changedIds) cache.itemsById.delete(id);
4708	for (const item of changedItems) {
4709	const existing = cache.itemsById.get(item.id) \|\| [];
4710	existing.push(item);
4711	cache.itemsById.set(item.id, existing);
4712	}
4713	}
4714	function rebuildCache(cache, allStyles, items) {
4715	cache.orderedIds = allStyles.map((style) => style.id).reverse();
4716	cache.itemsById.clear();
4717	for (const item of items) {
4718	const existing = cache.itemsById.get(item.id) \|\| [];
4719	existing.push(item);
4720	cache.itemsById.set(item.id, existing);
4721	}
4722	}
4723
4724	//#endregion
4725	//#region packages/packages/core/editor-canvas/src/components/style-renderer.tsx
4726	function StyleRenderer() {
4727	const container = usePortalContainer();
4728	const styleItems = useStyleItems();
4729	const linksAttrs = useDocumentsCssLinks();
4730	if (!container) return null;
4731	return /* @__PURE__ / react.createElement(_elementor_ui.Portal, { container }, filterUniqueStyleDefinitions(styleItems).map((item) => / @__PURE__ / react.createElement("style", { key: `${item.id}-${item.breakpoint}-${item.state ?? "normal"}` }, item.value)), linksAttrs.map((attrs) => / @__PURE__ */ react.createElement("link", {
4732	...attrs,
4733	key: attrs.id
4734	})));
4735	}
4736	function usePortalContainer() {
4737	return (0, _elementor_editor_v1_adapters.__privateUseListenTo)((0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview"), () => (0, _elementor_editor_v1_adapters.getCanvasIframeDocument)()?.head);
4738	}
4739	function filterUniqueStyleDefinitions(styleItems) {
4740	const seen = /* @__PURE__ */ new Map();
4741	return styleItems.filter((style) => {
4742	const existingStyle = seen.get(style.id);
4743	if (existingStyle) {
4744	if (existingStyle.find((s) => s.breakpoint === style.breakpoint && s.state === style.state)) return false;
4745	existingStyle.push(style);
4746	return true;
4747	}
4748	seen.set(style.id, [style]);
4749	return true;
4750	});
4751	}
4752
4753	//#endregion
4754	//#region packages/packages/core/editor-canvas/src/form-structure/utils.ts
4755	var FORM_ELEMENT_TYPE = "e-form";
4756	var FORM_FIELD_ELEMENT_TYPES = /* @__PURE__ */ new Set([
4757	"e-form-input",
4758	"e-form-textarea",
4759	"e-form-label",
4760	"e-form-checkbox",
4761	"e-form-submit-button",
4762	"e-form-select",
4763	"e-form-radio-button",
4764	"e-form-file-upload",
4765	"e-form-date-picker",
4766	"e-form-time-picker"
4767	]);
4768	function getArgsElementType(args) {
4769	return args.model?.widgetType \|\| args.model?.elType;
4770	}
4771	function getElementType$1(element) {
4772	return element?.model.get("widgetType") \|\| element?.model.get("elType");
4773	}
4774	__name(getElementType$1, "getElementType");
4775	function getClipboardElementType(element) {
4776	return element?.widgetType \|\| element?.elType;
4777	}
4778	function isElementWithinFormSelector(element) {
4779	return !!element?.view?.el?.closest("form,[data-element_type=\"e-form\"]");
4780	}
4781	function isWithinForm(element) {
4782	return isElementWithinFormSelector(element);
4783	}
4784	function hasElementType(element, type) {
4785	return (0, _elementor_editor_elements.getAllDescendants)(element).some((item) => getElementType$1(item) === type);
4786	}
4787	function hasElementTypes(element, types) {
4788	return (0, _elementor_editor_elements.getAllDescendants)(element).some((item) => {
4789	const itemType = getElementType$1(item);
4790	return itemType ? types.has(itemType) : false;
4791	});
4792	}
4793	function hasClipboardElementType(elements, type) {
4794	return elements.some((element) => {
4795	if (getClipboardElementType(element) === type) return true;
4796	return element.elements ? hasClipboardElementType(element.elements, type) : false;
4797	});
4798	}
4799	function hasClipboardElementTypes(elements, types) {
4800	return elements.some((element) => {
4801	const elementType = getClipboardElementType(element);
4802	if (elementType && types.has(elementType)) return true;
4803	return element.elements ? hasClipboardElementTypes(element.elements, types) : false;
4804	});
4805	}
4806	function movedContainersIncludeAtomicFormRoot(containers) {
4807	return containers.some((container) => getElementType$1(container) === FORM_ELEMENT_TYPE);
4808	}
4809	function clipboardRootsAreAtomicForms(elements) {
4810	if (!elements.length) return false;
4811	return elements.every((el) => getClipboardElementType(el) === FORM_ELEMENT_TYPE);
4812	}
4813
4814	//#endregion
4815	//#region packages/packages/core/editor-canvas/src/form-structure/enforce-form-ancestor-commands.ts
4816	var FORM_FIELDS_OUTSIDE_ALERT = {
4817	type: "default",
4818	message: (0, _wordpress_i18n.__)("Form elements must be placed inside a form.", "elementor"),
4819	id: "form-fields-outside-form-blocked"
4820	};
4821	function initFormAncestorEnforcement() {
4822	(0, _elementor_editor_v1_adapters.blockCommand)({
4823	command: "document/elements/create",
4824	condition: blockFormFieldCreate
4825	});
4826	(0, _elementor_editor_v1_adapters.blockCommand)({
4827	command: "document/elements/move",
4828	condition: blockFormFieldMove
4829	});
4830	(0, _elementor_editor_v1_adapters.blockCommand)({
4831	command: "document/elements/paste",
4832	condition: blockFormFieldPaste
4833	});
4834	}
4835	function blockFormFieldCreate(args) {
4836	const elementType = getArgsElementType(args);
4837	if (!elementType \|\| !FORM_FIELD_ELEMENT_TYPES.has(elementType)) return false;
4838	if ((args.containers ?? [args.container]).some((container) => !isWithinForm(container))) {
4839	handleBlockedFormField$1();
4840	return true;
4841	}
4842	return false;
4843	}
4844	function blockFormFieldMove(args) {
4845	const { containers = [args.container], target } = args;
4846	if (containers.some((container) => container ? !hasElementType(container, "e-form") && hasElementTypes(container, FORM_FIELD_ELEMENT_TYPES) : false) && !isWithinForm(target) && !movedContainersIncludeAtomicFormRoot(containers)) {
4847	handleBlockedFormField$1();
4848	return true;
4849	}
4850	return false;
4851	}
4852	function blockFormFieldPaste(args) {
4853	const { storageType } = args;
4854	if (storageType !== "localstorage") return false;
4855	const data = window?.elementorCommon?.storage?.get();
4856	if (!data?.clipboard?.elements) return false;
4857	if (hasClipboardElementTypes(data.clipboard.elements, FORM_FIELD_ELEMENT_TYPES) && !isWithinForm(args.container) && !clipboardRootsAreAtomicForms(data.clipboard.elements)) {
4858	handleBlockedFormField$1();
4859	return true;
4860	}
4861	return false;
4862	}
4863	function handleBlockedFormField$1() {
4864	(0, _elementor_editor_notifications.notify)(FORM_FIELDS_OUTSIDE_ALERT);
4865	}
4866	__name(handleBlockedFormField$1, "handleBlockedFormField");
4867
4868	//#endregion
4869	//#region packages/packages/core/editor-canvas/src/form-structure/prevent-form-nesting-commands.ts
4870	var FORM_NESTING_ALERT = {
4871	type: "default",
4872	message: (0, _wordpress_i18n.__)("Forms can't be nested. Create separate forms instead.", "elementor"),
4873	id: "form-nesting-blocked"
4874	};
4875	function initFormNestingPrevention() {
4876	(0, _elementor_editor_v1_adapters.blockCommand)({
4877	command: "document/elements/create",
4878	condition: blockFormCreate
4879	});
4880	(0, _elementor_editor_v1_adapters.blockCommand)({
4881	command: "document/elements/move",
4882	condition: blockFormMove
4883	});
4884	(0, _elementor_editor_v1_adapters.blockCommand)({
4885	command: "document/elements/paste",
4886	condition: blockFormPaste
4887	});
4888	}
4889	function blockFormCreate(args) {
4890	const elementType = getArgsElementType(args);
4891	if (!elementType) return false;
4892	if (elementType === "e-form" && isWithinForm(args.container)) {
4893	handleBlockedFormField();
4894	return true;
4895	}
4896	return false;
4897	}
4898	function blockFormMove(args) {
4899	const { containers = [args.container], target } = args;
4900	if (containers.some((container) => container ? hasElementType(container, "e-form") : false) && isWithinForm(target)) {
4901	handleBlockedFormField();
4902	return true;
4903	}
4904	return false;
4905	}
4906	function blockFormPaste(args) {
4907	const { storageType } = args;
4908	if (storageType !== "localstorage") return false;
4909	const data = window?.elementorCommon?.storage?.get();
4910	if (!data?.clipboard?.elements) return false;
4911	if (hasClipboardElementType(data.clipboard.elements, "e-form") && isWithinForm(args.container)) {
4912	handleBlockedFormField();
4913	return true;
4914	}
4915	return false;
4916	}
4917	function handleBlockedFormField() {
4918	(0, _elementor_editor_notifications.notify)(FORM_NESTING_ALERT);
4919	}
4920
4921	//#endregion
4922	//#region packages/packages/core/editor-canvas/src/settings-transformers-registry.ts
4923	var settingsTransformersRegistry = createTransformersRegistry();
4924
4925	//#endregion
4926	//#region packages/packages/core/editor-canvas/src/transformers/create-transformer.ts
4927	function createTransformer(cb) {
4928	return cb;
4929	}
4930
4931	//#endregion
4932	//#region packages/packages/core/editor-canvas/src/transformers/settings/attributes-transformer.ts
4933	var attributesTransformer = createTransformer(() => "");
4934
4935	//#endregion
4936	//#region packages/packages/core/editor-canvas/src/transformers/settings/classes-transformer.ts
4937	function transformClassId(id, cache) {
4938	if (!cache.has(id)) {
4939	const provider2 = _elementor_editor_styles_repository.stylesRepository.getProviders().find((p) => {
4940	return p.actions.all().find((style) => style.id === id);
4941	});
4942	if (!provider2) return id;
4943	cache.set(id, provider2.getKey());
4944	}
4945	const providerKey = cache.get(id);
4946	return _elementor_editor_styles_repository.stylesRepository.getProviderByKey(providerKey)?.actions.resolveCssName(id) ?? id;
4947	}
4948	function createClassesTransformer() {
4949	const cache = /* @__PURE__ */ new Map();
4950	return createTransformer((value) => {
4951	return value.map((id) => transformClassId(id, cache)).filter(Boolean);
4952	});
4953	}
4954
4955	//#endregion
4956	//#region packages/packages/core/editor-canvas/src/transformers/settings/date-range-transformer.ts
4957	var dateRangeTransformer = createTransformer((value) => {
4958	if (!value \|\| Object.keys(value).length === 0) return null;
4959	return {
4960	min: value.min \|\| null,
4961	max: value.max \|\| null
4962	};
4963	});
4964
4965	//#endregion
4966	//#region packages/packages/core/editor-canvas/src/transformers/settings/date-time-transformer.ts
4967	var dateTimeTransformer = createTransformer((values) => {
4968	return values.map((value) => {
4969	const date = (value.date \|\| "").trim();
4970	const time = (value.time \|\| "").trim();
4971	return !date && !time ? "" : `${date} ${time}`.trim();
4972	}).join(" ");
4973	});
4974
4975	//#endregion
4976	//#region node_modules/dompurify/dist/purify.es.mjs
4977	/! @license DOMPurify 3.3.0 \| (c) Cure53 and other contributors \| Released under the Apache license 2.0 and Mozilla Public License 2.0 \| github.com/cure53/DOMPurify/blob/3.3.0/LICENSE /
4978	var { entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor } = Object;
4979	var { freeze, seal, create } = Object;
4980	var { apply, construct } = typeof Reflect !== "undefined" && Reflect;
4981	if (!freeze) freeze = function freeze(x) {
4982	return x;
4983	};
4984	if (!seal) seal = function seal(x) {
4985	return x;
4986	};
4987	if (!apply) apply = function apply(func, thisArg) {
4988	for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) args[_key - 2] = arguments[_key];
4989	return func.apply(thisArg, args);
4990	};
4991	if (!construct) construct = function construct(Func) {
4992	for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
4993	return new Func(...args);
4994	};
4995	var arrayForEach = unapply(Array.prototype.forEach);
4996	var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
4997	var arrayPop = unapply(Array.prototype.pop);
4998	var arrayPush = unapply(Array.prototype.push);
4999	var arraySplice = unapply(Array.prototype.splice);
5000	var stringToLowerCase = unapply(String.prototype.toLowerCase);
5001	var stringToString = unapply(String.prototype.toString);
5002	var stringMatch = unapply(String.prototype.match);
5003	var stringReplace = unapply(String.prototype.replace);
5004	var stringIndexOf = unapply(String.prototype.indexOf);
5005	var stringTrim = unapply(String.prototype.trim);
5006	var objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
5007	var regExpTest = unapply(RegExp.prototype.test);
5008	var typeErrorCreate = unconstruct(TypeError);
5009	/**
5010	* Creates a new function that calls the given function with a specified thisArg and arguments.
5011	*
5012	* @param func - The function to be wrapped and called.
5013	* @returns A new function that calls the given function with a specified thisArg and arguments.
5014	*/
5015	function unapply(func) {
5016	return function(thisArg) {
5017	if (thisArg instanceof RegExp) thisArg.lastIndex = 0;
5018	for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) args[_key3 - 1] = arguments[_key3];
5019	return apply(func, thisArg, args);
5020	};
5021	}
5022	/**
5023	* Creates a new function that constructs an instance of the given constructor function with the provided arguments.
5024	*
5025	* @param func - The constructor function to be wrapped and called.
5026	* @returns A new function that constructs an instance of the given constructor function with the provided arguments.
5027	*/
5028	function unconstruct(Func) {
5029	return function() {
5030	for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) args[_key4] = arguments[_key4];
5031	return construct(Func, args);
5032	};
5033	}
5034	/**
5035	* Add properties to a lookup table
5036	*
5037	* @param set - The set to which elements will be added.
5038	* @param array - The array containing elements to be added to the set.
5039	* @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
5040	* @returns The modified set with added elements.
5041	*/
5042	function addToSet(set, array) {
5043	let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
5044	if (setPrototypeOf) setPrototypeOf(set, null);
5045	let l = array.length;
5046	while (l--) {
5047	let element = array[l];
5048	if (typeof element === "string") {
5049	const lcElement = transformCaseFunc(element);
5050	if (lcElement !== element) {
5051	if (!isFrozen(array)) array[l] = lcElement;
5052	element = lcElement;
5053	}
5054	}
5055	set[element] = true;
5056	}
5057	return set;
5058	}
5059	/**
5060	* Clean up an array to harden against CSPP
5061	*
5062	* @param array - The array to be cleaned.
5063	* @returns The cleaned version of the array
5064	*/
5065	function cleanArray(array) {
5066	for (let index = 0; index < array.length; index++) if (!objectHasOwnProperty(array, index)) array[index] = null;
5067	return array;
5068	}
5069	/**
5070	* Shallow clone an object
5071	*
5072	* @param object - The object to be cloned.
5073	* @returns A new object that copies the original.
5074	*/
5075	function clone(object) {
5076	const newObject = create(null);
5077	for (const [property, value] of entries(object)) if (objectHasOwnProperty(object, property)) if (Array.isArray(value)) newObject[property] = cleanArray(value);
5078	else if (value && typeof value === "object" && value.constructor === Object) newObject[property] = clone(value);
5079	else newObject[property] = value;
5080	return newObject;
5081	}
5082	/**
5083	* This method automatically checks if the prop is function or getter and behaves accordingly.
5084	*
5085	* @param object - The object to look up the getter function in its prototype chain.
5086	* @param prop - The property name for which to find the getter function.
5087	* @returns The getter function found in the prototype chain or a fallback function.
5088	*/
5089	function lookupGetter(object, prop) {
5090	while (object !== null) {
5091	const desc = getOwnPropertyDescriptor(object, prop);
5092	if (desc) {
5093	if (desc.get) return unapply(desc.get);
5094	if (typeof desc.value === "function") return unapply(desc.value);
5095	}
5096	object = getPrototypeOf(object);
5097	}
5098	function fallbackValue() {
5099	return null;
5100	}
5101	return fallbackValue;
5102	}
5103	var html$1 = freeze([
5104	"a",
5105	"abbr",
5106	"acronym",
5107	"address",
5108	"area",
5109	"article",
5110	"aside",
5111	"audio",
5112	"b",
5113	"bdi",
5114	"bdo",
5115	"big",
5116	"blink",
5117	"blockquote",
5118	"body",
5119	"br",
5120	"button",
5121	"canvas",
5122	"caption",
5123	"center",
5124	"cite",
5125	"code",
5126	"col",
5127	"colgroup",
5128	"content",
5129	"data",
5130	"datalist",
5131	"dd",
5132	"decorator",
5133	"del",
5134	"details",
5135	"dfn",
5136	"dialog",
5137	"dir",
5138	"div",
5139	"dl",
5140	"dt",
5141	"element",
5142	"em",
5143	"fieldset",
5144	"figcaption",
5145	"figure",
5146	"font",
5147	"footer",
5148	"form",
5149	"h1",
5150	"h2",
5151	"h3",
5152	"h4",
5153	"h5",
5154	"h6",
5155	"head",
5156	"header",
5157	"hgroup",
5158	"hr",
5159	"html",
5160	"i",
5161	"img",
5162	"input",
5163	"ins",
5164	"kbd",
5165	"label",
5166	"legend",
5167	"li",
5168	"main",
5169	"map",
5170	"mark",
5171	"marquee",
5172	"menu",
5173	"menuitem",
5174	"meter",
5175	"nav",
5176	"nobr",
5177	"ol",
5178	"optgroup",
5179	"option",
5180	"output",
5181	"p",
5182	"picture",
5183	"pre",
5184	"progress",
5185	"q",
5186	"rp",
5187	"rt",
5188	"ruby",
5189	"s",
5190	"samp",
5191	"search",
5192	"section",
5193	"select",
5194	"shadow",
5195	"slot",
5196	"small",
5197	"source",
5198	"spacer",
5199	"span",
5200	"strike",
5201	"strong",
5202	"style",
5203	"sub",
5204	"summary",
5205	"sup",
5206	"table",
5207	"tbody",
5208	"td",
5209	"template",
5210	"textarea",
5211	"tfoot",
5212	"th",
5213	"thead",
5214	"time",
5215	"tr",
5216	"track",
5217	"tt",
5218	"u",
5219	"ul",
5220	"var",
5221	"video",
5222	"wbr"
5223	]);
5224	var svg$1 = freeze([
5225	"svg",
5226	"a",
5227	"altglyph",
5228	"altglyphdef",
5229	"altglyphitem",
5230	"animatecolor",
5231	"animatemotion",
5232	"animatetransform",
5233	"circle",
5234	"clippath",
5235	"defs",
5236	"desc",
5237	"ellipse",
5238	"enterkeyhint",
5239	"exportparts",
5240	"filter",
5241	"font",
5242	"g",
5243	"glyph",
5244	"glyphref",
5245	"hkern",
5246	"image",
5247	"inputmode",
5248	"line",
5249	"lineargradient",
5250	"marker",
5251	"mask",
5252	"metadata",
5253	"mpath",
5254	"part",
5255	"path",
5256	"pattern",
5257	"polygon",
5258	"polyline",
5259	"radialgradient",
5260	"rect",
5261	"stop",
5262	"style",
5263	"switch",
5264	"symbol",
5265	"text",
5266	"textpath",
5267	"title",
5268	"tref",
5269	"tspan",
5270	"view",
5271	"vkern"
5272	]);
5273	var svgFilters = freeze([
5274	"feBlend",
5275	"feColorMatrix",
5276	"feComponentTransfer",
5277	"feComposite",
5278	"feConvolveMatrix",
5279	"feDiffuseLighting",
5280	"feDisplacementMap",
5281	"feDistantLight",
5282	"feDropShadow",
5283	"feFlood",
5284	"feFuncA",
5285	"feFuncB",
5286	"feFuncG",
5287	"feFuncR",
5288	"feGaussianBlur",
5289	"feImage",
5290	"feMerge",
5291	"feMergeNode",
5292	"feMorphology",
5293	"feOffset",
5294	"fePointLight",
5295	"feSpecularLighting",
5296	"feSpotLight",
5297	"feTile",
5298	"feTurbulence"
5299	]);
5300	var svgDisallowed = freeze([
5301	"animate",
5302	"color-profile",
5303	"cursor",
5304	"discard",
5305	"font-face",
5306	"font-face-format",
5307	"font-face-name",
5308	"font-face-src",
5309	"font-face-uri",
5310	"foreignobject",
5311	"hatch",
5312	"hatchpath",
5313	"mesh",
5314	"meshgradient",
5315	"meshpatch",
5316	"meshrow",
5317	"missing-glyph",
5318	"script",
5319	"set",
5320	"solidcolor",
5321	"unknown",
5322	"use"
5323	]);
5324	var mathMl$1 = freeze([
5325	"math",
5326	"menclose",
5327	"merror",
5328	"mfenced",
5329	"mfrac",
5330	"mglyph",
5331	"mi",
5332	"mlabeledtr",
5333	"mmultiscripts",
5334	"mn",
5335	"mo",
5336	"mover",
5337	"mpadded",
5338	"mphantom",
5339	"mroot",
5340	"mrow",
5341	"ms",
5342	"mspace",
5343	"msqrt",
5344	"mstyle",
5345	"msub",
5346	"msup",
5347	"msubsup",
5348	"mtable",
5349	"mtd",
5350	"mtext",
5351	"mtr",
5352	"munder",
5353	"munderover",
5354	"mprescripts"
5355	]);
5356	var mathMlDisallowed = freeze([
5357	"maction",
5358	"maligngroup",
5359	"malignmark",
5360	"mlongdiv",
5361	"mscarries",
5362	"mscarry",
5363	"msgroup",
5364	"mstack",
5365	"msline",
5366	"msrow",
5367	"semantics",
5368	"annotation",
5369	"annotation-xml",
5370	"mprescripts",
5371	"none"
5372	]);
5373	var text = freeze(["#text"]);
5374	var html = freeze([
5375	"accept",
5376	"action",
5377	"align",
5378	"alt",
5379	"autocapitalize",
5380	"autocomplete",
5381	"autopictureinpicture",
5382	"autoplay",
5383	"background",
5384	"bgcolor",
5385	"border",
5386	"capture",
5387	"cellpadding",
5388	"cellspacing",
5389	"checked",
5390	"cite",
5391	"class",
5392	"clear",
5393	"color",
5394	"cols",
5395	"colspan",
5396	"controls",
5397	"controlslist",
5398	"coords",
5399	"crossorigin",
5400	"datetime",
5401	"decoding",
5402	"default",
5403	"dir",
5404	"disabled",
5405	"disablepictureinpicture",
5406	"disableremoteplayback",
5407	"download",
5408	"draggable",
5409	"enctype",
5410	"enterkeyhint",
5411	"exportparts",
5412	"face",
5413	"for",
5414	"headers",
5415	"height",
5416	"hidden",
5417	"high",
5418	"href",
5419	"hreflang",
5420	"id",
5421	"inert",
5422	"inputmode",
5423	"integrity",
5424	"ismap",
5425	"kind",
5426	"label",
5427	"lang",
5428	"list",
5429	"loading",
5430	"loop",
5431	"low",
5432	"max",
5433	"maxlength",
5434	"media",
5435	"method",
5436	"min",
5437	"minlength",
5438	"multiple",
5439	"muted",
5440	"name",
5441	"nonce",
5442	"noshade",
5443	"novalidate",
5444	"nowrap",
5445	"open",
5446	"optimum",
5447	"part",
5448	"pattern",
5449	"placeholder",
5450	"playsinline",
5451	"popover",
5452	"popovertarget",
5453	"popovertargetaction",
5454	"poster",
5455	"preload",
5456	"pubdate",
5457	"radiogroup",
5458	"readonly",
5459	"rel",
5460	"required",
5461	"rev",
5462	"reversed",
5463	"role",
5464	"rows",
5465	"rowspan",
5466	"spellcheck",
5467	"scope",
5468	"selected",
5469	"shape",
5470	"size",
5471	"sizes",
5472	"slot",
5473	"span",
5474	"srclang",
5475	"start",
5476	"src",
5477	"srcset",
5478	"step",
5479	"style",
5480	"summary",
5481	"tabindex",
5482	"title",
5483	"translate",
5484	"type",
5485	"usemap",
5486	"valign",
5487	"value",
5488	"width",
5489	"wrap",
5490	"xmlns",
5491	"slot"
5492	]);
5493	var svg = freeze([
5494	"accent-height",
5495	"accumulate",
5496	"additive",
5497	"alignment-baseline",
5498	"amplitude",
5499	"ascent",
5500	"attributename",
5501	"attributetype",
5502	"azimuth",
5503	"basefrequency",
5504	"baseline-shift",
5505	"begin",
5506	"bias",
5507	"by",
5508	"class",
5509	"clip",
5510	"clippathunits",
5511	"clip-path",
5512	"clip-rule",
5513	"color",
5514	"color-interpolation",
5515	"color-interpolation-filters",
5516	"color-profile",
5517	"color-rendering",
5518	"cx",
5519	"cy",
5520	"d",
5521	"dx",
5522	"dy",
5523	"diffuseconstant",
5524	"direction",
5525	"display",
5526	"divisor",
5527	"dur",
5528	"edgemode",
5529	"elevation",
5530	"end",
5531	"exponent",
5532	"fill",
5533	"fill-opacity",
5534	"fill-rule",
5535	"filter",
5536	"filterunits",
5537	"flood-color",
5538	"flood-opacity",
5539	"font-family",
5540	"font-size",
5541	"font-size-adjust",
5542	"font-stretch",
5543	"font-style",
5544	"font-variant",
5545	"font-weight",
5546	"fx",
5547	"fy",
5548	"g1",
5549	"g2",
5550	"glyph-name",
5551	"glyphref",
5552	"gradientunits",
5553	"gradienttransform",
5554	"height",
5555	"href",
5556	"id",
5557	"image-rendering",
5558	"in",
5559	"in2",
5560	"intercept",
5561	"k",
5562	"k1",
5563	"k2",
5564	"k3",
5565	"k4",
5566	"kerning",
5567	"keypoints",
5568	"keysplines",
5569	"keytimes",
5570	"lang",
5571	"lengthadjust",
5572	"letter-spacing",
5573	"kernelmatrix",
5574	"kernelunitlength",
5575	"lighting-color",
5576	"local",
5577	"marker-end",
5578	"marker-mid",
5579	"marker-start",
5580	"markerheight",
5581	"markerunits",
5582	"markerwidth",
5583	"maskcontentunits",
5584	"maskunits",
5585	"max",
5586	"mask",
5587	"mask-type",
5588	"media",
5589	"method",
5590	"mode",
5591	"min",
5592	"name",
5593	"numoctaves",
5594	"offset",
5595	"operator",
5596	"opacity",
5597	"order",
5598	"orient",
5599	"orientation",
5600	"origin",
5601	"overflow",
5602	"paint-order",
5603	"path",
5604	"pathlength",
5605	"patterncontentunits",
5606	"patterntransform",
5607	"patternunits",
5608	"points",
5609	"preservealpha",
5610	"preserveaspectratio",
5611	"primitiveunits",
5612	"r",
5613	"rx",
5614	"ry",
5615	"radius",
5616	"refx",
5617	"refy",
5618	"repeatcount",
5619	"repeatdur",
5620	"restart",
5621	"result",
5622	"rotate",
5623	"scale",
5624	"seed",
5625	"shape-rendering",
5626	"slope",
5627	"specularconstant",
5628	"specularexponent",
5629	"spreadmethod",
5630	"startoffset",
5631	"stddeviation",
5632	"stitchtiles",
5633	"stop-color",
5634	"stop-opacity",
5635	"stroke-dasharray",
5636	"stroke-dashoffset",
5637	"stroke-linecap",
5638	"stroke-linejoin",
5639	"stroke-miterlimit",
5640	"stroke-opacity",
5641	"stroke",
5642	"stroke-width",
5643	"style",
5644	"surfacescale",
5645	"systemlanguage",
5646	"tabindex",
5647	"tablevalues",
5648	"targetx",
5649	"targety",
5650	"transform",
5651	"transform-origin",
5652	"text-anchor",
5653	"text-decoration",
5654	"text-rendering",
5655	"textlength",
5656	"type",
5657	"u1",
5658	"u2",
5659	"unicode",
5660	"values",
5661	"viewbox",
5662	"visibility",
5663	"version",
5664	"vert-adv-y",
5665	"vert-origin-x",
5666	"vert-origin-y",
5667	"width",
5668	"word-spacing",
5669	"wrap",
5670	"writing-mode",
5671	"xchannelselector",
5672	"ychannelselector",
5673	"x",
5674	"x1",
5675	"x2",
5676	"xmlns",
5677	"y",
5678	"y1",
5679	"y2",
5680	"z",
5681	"zoomandpan"
5682	]);
5683	var mathMl = freeze([
5684	"accent",
5685	"accentunder",
5686	"align",
5687	"bevelled",
5688	"close",
5689	"columnsalign",
5690	"columnlines",
5691	"columnspan",
5692	"denomalign",
5693	"depth",
5694	"dir",
5695	"display",
5696	"displaystyle",
5697	"encoding",
5698	"fence",
5699	"frame",
5700	"height",
5701	"href",
5702	"id",
5703	"largeop",
5704	"length",
5705	"linethickness",
5706	"lspace",
5707	"lquote",
5708	"mathbackground",
5709	"mathcolor",
5710	"mathsize",
5711	"mathvariant",
5712	"maxsize",
5713	"minsize",
5714	"movablelimits",
5715	"notation",
5716	"numalign",
5717	"open",
5718	"rowalign",
5719	"rowlines",
5720	"rowspacing",
5721	"rowspan",
5722	"rspace",
5723	"rquote",
5724	"scriptlevel",
5725	"scriptminsize",
5726	"scriptsizemultiplier",
5727	"selection",
5728	"separator",
5729	"separators",
5730	"stretchy",
5731	"subscriptshift",
5732	"supscriptshift",
5733	"symmetric",
5734	"voffset",
5735	"width",
5736	"xmlns"
5737	]);
5738	var xml = freeze([
5739	"xlink:href",
5740	"xml:id",
5741	"xlink:title",
5742	"xml:space",
5743	"xmlns:xlink"
5744	]);
5745	var MUSTACHE_EXPR = seal(/\{\{[\w\W]\|[\w\W]\}\}/gm);
5746	var ERB_EXPR = seal(/<%[\w\W]\|[\w\W]%>/gm);
5747	var TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm);
5748	var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
5749	var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
5750	var IS_ALLOWED_URI = seal(/^(?:(?:(?:f\|ht)tps?\|mailto\|tel\|callto\|sms\|cid\|xmpp\|matrix):\|[^a-z]\|[a-z+.\-]+(?:[^a-z+.\-:]\|$))/i);
5751	var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script\|data):/i);
5752	var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
5753	var DOCTYPE_NAME = seal(/^html$/i);
5754	var CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
5755	var EXPRESSIONS = /#__PURE__/ Object.freeze({
5756	__proto__: null,
5757	ARIA_ATTR,
5758	ATTR_WHITESPACE,
5759	CUSTOM_ELEMENT,
5760	DATA_ATTR,
5761	DOCTYPE_NAME,
5762	ERB_EXPR,
5763	IS_ALLOWED_URI,
5764	IS_SCRIPT_OR_DATA,
5765	MUSTACHE_EXPR,
5766	TMPLIT_EXPR
5767	});
5768	var NODE_TYPE = {
5769	element: 1,
5770	attribute: 2,
5771	text: 3,
5772	cdataSection: 4,
5773	entityReference: 5,
5774	entityNode: 6,
5775	progressingInstruction: 7,
5776	comment: 8,
5777	document: 9,
5778	documentType: 10,
5779	documentFragment: 11,
5780	notation: 12
5781	};
5782	var getGlobal = function getGlobal() {
5783	return typeof window === "undefined" ? null : window;
5784	};
5785	/**
5786	* Creates a no-op policy for internal use only.
5787	* Don't export this function outside this module!
5788	* @param trustedTypes The policy factory.
5789	* @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
5790	* @return The policy created (or null, if Trusted Types
5791	* are not supported or creating the policy failed).
5792	*/
5793	var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
5794	if (typeof trustedTypes !== "object" \|\| typeof trustedTypes.createPolicy !== "function") return null;
5795	let suffix = null;
5796	const ATTR_NAME = "data-tt-policy-suffix";
5797	if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) suffix = purifyHostElement.getAttribute(ATTR_NAME);
5798	const policyName = "dompurify" + (suffix ? "#" + suffix : "");
5799	try {
5800	return trustedTypes.createPolicy(policyName, {
5801	createHTML(html) {
5802	return html;
5803	},
5804	createScriptURL(scriptUrl) {
5805	return scriptUrl;
5806	}
5807	});
5808	} catch (_) {
5809	console.warn("TrustedTypes policy " + policyName + " could not be created.");
5810	return null;
5811	}
5812	};
5813	var _createHooksMap = function _createHooksMap() {
5814	return {
5815	afterSanitizeAttributes: [],
5816	afterSanitizeElements: [],
5817	afterSanitizeShadowDOM: [],
5818	beforeSanitizeAttributes: [],
5819	beforeSanitizeElements: [],
5820	beforeSanitizeShadowDOM: [],
5821	uponSanitizeAttribute: [],
5822	uponSanitizeElement: [],
5823	uponSanitizeShadowNode: []
5824	};
5825	};
5826	function createDOMPurify() {
5827	let window = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
5828	const DOMPurify = (root) => createDOMPurify(root);
5829	DOMPurify.version = "3.3.0";
5830	DOMPurify.removed = [];
5831	if (!window \|\| !window.document \|\| window.document.nodeType !== NODE_TYPE.document \|\| !window.Element) {
5832	DOMPurify.isSupported = false;
5833	return DOMPurify;
5834	}
5835	let { document } = window;
5836	const originalDocument = document;
5837	const currentScript = originalDocument.currentScript;
5838	const { DocumentFragment, HTMLTemplateElement, Node, Element, NodeFilter, NamedNodeMap = window.NamedNodeMap \|\| window.MozNamedAttrMap, HTMLFormElement, DOMParser, trustedTypes } = window;
5839	const ElementPrototype = Element.prototype;
5840	const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
5841	const remove = lookupGetter(ElementPrototype, "remove");
5842	const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
5843	const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
5844	const getParentNode = lookupGetter(ElementPrototype, "parentNode");
5845	if (typeof HTMLTemplateElement === "function") {
5846	const template = document.createElement("template");
5847	if (template.content && template.content.ownerDocument) document = template.content.ownerDocument;
5848	}
5849	let trustedTypesPolicy;
5850	let emptyHTML = "";
5851	const { implementation, createNodeIterator, createDocumentFragment, getElementsByTagName } = document;
5852	const { importNode } = originalDocument;
5853	let hooks = _createHooksMap();
5854	/**
5855	* Expose whether this browser supports running the full DOMPurify.
5856	*/
5857	DOMPurify.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
5858	const { MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, CUSTOM_ELEMENT } = EXPRESSIONS;
5859	let { IS_ALLOWED_URI: IS_ALLOWED_URI$1 } = EXPRESSIONS;
5860	/**
5861	* We consider the elements and attributes below to be safe. Ideally
5862	* don't add any new ones but feel free to remove unwanted ones.
5863	*/
5864	let ALLOWED_TAGS = null;
5865	const DEFAULT_ALLOWED_TAGS = addToSet({}, [
5866	...html$1,
5867	...svg$1,
5868	...svgFilters,
5869	...mathMl$1,
5870	...text
5871	]);
5872	let ALLOWED_ATTR = null;
5873	const DEFAULT_ALLOWED_ATTR = addToSet({}, [
5874	...html,
5875	...svg,
5876	...mathMl,
5877	...xml
5878	]);
5879	let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
5880	tagNameCheck: {
5881	writable: true,
5882	configurable: false,
5883	enumerable: true,
5884	value: null
5885	},
5886	attributeNameCheck: {
5887	writable: true,
5888	configurable: false,
5889	enumerable: true,
5890	value: null
5891	},
5892	allowCustomizedBuiltInElements: {
5893	writable: true,
5894	configurable: false,
5895	enumerable: true,
5896	value: false
5897	}
5898	}));
5899	let FORBID_TAGS = null;
5900	let FORBID_ATTR = null;
5901	const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
5902	tagCheck: {
5903	writable: true,
5904	configurable: false,
5905	enumerable: true,
5906	value: null
5907	},
5908	attributeCheck: {
5909	writable: true,
5910	configurable: false,
5911	enumerable: true,
5912	value: null
5913	}
5914	}));
5915	let ALLOW_ARIA_ATTR = true;
5916	let ALLOW_DATA_ATTR = true;
5917	let ALLOW_UNKNOWN_PROTOCOLS = false;
5918	let ALLOW_SELF_CLOSE_IN_ATTR = true;
5919	let SAFE_FOR_TEMPLATES = false;
5920	let SAFE_FOR_XML = true;
5921	let WHOLE_DOCUMENT = false;
5922	let SET_CONFIG = false;
5923	let FORCE_BODY = false;
5924	let RETURN_DOM = false;
5925	let RETURN_DOM_FRAGMENT = false;
5926	let RETURN_TRUSTED_TYPE = false;
5927	let SANITIZE_DOM = true;
5928	let SANITIZE_NAMED_PROPS = false;
5929	const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
5930	let KEEP_CONTENT = true;
5931	let IN_PLACE = false;
5932	let USE_PROFILES = {};
5933	let FORBID_CONTENTS = null;
5934	const DEFAULT_FORBID_CONTENTS = addToSet({}, [
5935	"annotation-xml",
5936	"audio",
5937	"colgroup",
5938	"desc",
5939	"foreignobject",
5940	"head",
5941	"iframe",
5942	"math",
5943	"mi",
5944	"mn",
5945	"mo",
5946	"ms",
5947	"mtext",
5948	"noembed",
5949	"noframes",
5950	"noscript",
5951	"plaintext",
5952	"script",
5953	"style",
5954	"svg",
5955	"template",
5956	"thead",
5957	"title",
5958	"video",
5959	"xmp"
5960	]);
5961	let DATA_URI_TAGS = null;
5962	const DEFAULT_DATA_URI_TAGS = addToSet({}, [
5963	"audio",
5964	"video",
5965	"img",
5966	"source",
5967	"image",
5968	"track"
5969	]);
5970	let URI_SAFE_ATTRIBUTES = null;
5971	const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, [
5972	"alt",
5973	"class",
5974	"for",
5975	"id",
5976	"label",
5977	"name",
5978	"pattern",
5979	"placeholder",
5980	"role",
5981	"summary",
5982	"title",
5983	"value",
5984	"style",
5985	"xmlns"
5986	]);
5987	const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
5988	const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
5989	const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
5990	let NAMESPACE = HTML_NAMESPACE;
5991	let IS_EMPTY_INPUT = false;
5992	let ALLOWED_NAMESPACES = null;
5993	const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [
5994	MATHML_NAMESPACE,
5995	SVG_NAMESPACE,
5996	HTML_NAMESPACE
5997	], stringToString);
5998	let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, [
5999	"mi",
6000	"mo",
6001	"mn",
6002	"ms",
6003	"mtext"
6004	]);
6005	let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
6006	const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, [
6007	"title",
6008	"style",
6009	"font",
6010	"a",
6011	"script"
6012	]);
6013	let PARSER_MEDIA_TYPE = null;
6014	const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
6015	const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
6016	let transformCaseFunc = null;
6017	let CONFIG = null;
6018	const formElement = document.createElement("form");
6019	const isRegexOrFunction = function isRegexOrFunction(testValue) {
6020	return testValue instanceof RegExp \|\| testValue instanceof Function;
6021	};
6022	/**
6023	* _parseConfig
6024	*
6025	* @param cfg optional config literal
6026	*/
6027	const _parseConfig = function _parseConfig() {
6028	let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
6029	if (CONFIG && CONFIG === cfg) return;
6030	if (!cfg \|\| typeof cfg !== "object") cfg = {};
6031	cfg = clone(cfg);
6032	PARSER_MEDIA_TYPE = SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
6033	transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
6034	ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
6035	ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
6036	ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
6037	URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
6038	DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
6039	FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
6040	FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
6041	FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
6042	USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES : false;
6043	ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
6044	ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
6045	ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS \|\| false;
6046	ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
6047	SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES \|\| false;
6048	SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
6049	WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT \|\| false;
6050	RETURN_DOM = cfg.RETURN_DOM \|\| false;
6051	RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT \|\| false;
6052	RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE \|\| false;
6053	FORCE_BODY = cfg.FORCE_BODY \|\| false;
6054	SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
6055	SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS \|\| false;
6056	KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
6057	IN_PLACE = cfg.IN_PLACE \|\| false;
6058	IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP \|\| IS_ALLOWED_URI;
6059	NAMESPACE = cfg.NAMESPACE \|\| HTML_NAMESPACE;
6060	MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS \|\| MATHML_TEXT_INTEGRATION_POINTS;
6061	HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS \|\| HTML_INTEGRATION_POINTS;
6062	CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING \|\| {};
6063	if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
6064	if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
6065	if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
6066	if (SAFE_FOR_TEMPLATES) ALLOW_DATA_ATTR = false;
6067	if (RETURN_DOM_FRAGMENT) RETURN_DOM = true;
6068	if (USE_PROFILES) {
6069	ALLOWED_TAGS = addToSet({}, text);
6070	ALLOWED_ATTR = [];
6071	if (USE_PROFILES.html === true) {
6072	addToSet(ALLOWED_TAGS, html$1);
6073	addToSet(ALLOWED_ATTR, html);
6074	}
6075	if (USE_PROFILES.svg === true) {
6076	addToSet(ALLOWED_TAGS, svg$1);
6077	addToSet(ALLOWED_ATTR, svg);
6078	addToSet(ALLOWED_ATTR, xml);
6079	}
6080	if (USE_PROFILES.svgFilters === true) {
6081	addToSet(ALLOWED_TAGS, svgFilters);
6082	addToSet(ALLOWED_ATTR, svg);
6083	addToSet(ALLOWED_ATTR, xml);
6084	}
6085	if (USE_PROFILES.mathMl === true) {
6086	addToSet(ALLOWED_TAGS, mathMl$1);
6087	addToSet(ALLOWED_ATTR, mathMl);
6088	addToSet(ALLOWED_ATTR, xml);
6089	}
6090	}
6091	if (cfg.ADD_TAGS) if (typeof cfg.ADD_TAGS === "function") EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
6092	else {
6093	if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) ALLOWED_TAGS = clone(ALLOWED_TAGS);
6094	addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
6095	}
6096	if (cfg.ADD_ATTR) if (typeof cfg.ADD_ATTR === "function") EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
6097	else {
6098	if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) ALLOWED_ATTR = clone(ALLOWED_ATTR);
6099	addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
6100	}
6101	if (cfg.ADD_URI_SAFE_ATTR) addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
6102	if (cfg.FORBID_CONTENTS) {
6103	if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) FORBID_CONTENTS = clone(FORBID_CONTENTS);
6104	addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
6105	}
6106	if (KEEP_CONTENT) ALLOWED_TAGS["#text"] = true;
6107	if (WHOLE_DOCUMENT) addToSet(ALLOWED_TAGS, [
6108	"html",
6109	"head",
6110	"body"
6111	]);
6112	if (ALLOWED_TAGS.table) {
6113	addToSet(ALLOWED_TAGS, ["tbody"]);
6114	delete FORBID_TAGS.tbody;
6115	}
6116	if (cfg.TRUSTED_TYPES_POLICY) {
6117	if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") throw typeErrorCreate("TRUSTED_TYPES_POLICY configuration option must provide a \"createHTML\" hook.");
6118	if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") throw typeErrorCreate("TRUSTED_TYPES_POLICY configuration option must provide a \"createScriptURL\" hook.");
6119	trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
6120	emptyHTML = trustedTypesPolicy.createHTML("");
6121	} else {
6122	if (trustedTypesPolicy === void 0) trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
6123	if (trustedTypesPolicy !== null && typeof emptyHTML === "string") emptyHTML = trustedTypesPolicy.createHTML("");
6124	}
6125	if (freeze) freeze(cfg);
6126	CONFIG = cfg;
6127	};
6128	const ALL_SVG_TAGS = addToSet({}, [
6129	...svg$1,
6130	...svgFilters,
6131	...svgDisallowed
6132	]);
6133	const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
6134	/**
6135	* @param element a DOM element whose namespace is being checked
6136	* @returns Return false if the element has a
6137	* namespace that a spec-compliant parser would never
6138	* return. Return true otherwise.
6139	*/
6140	const _checkValidNamespace = function _checkValidNamespace(element) {
6141	let parent = getParentNode(element);
6142	if (!parent \|\| !parent.tagName) parent = {
6143	namespaceURI: NAMESPACE,
6144	tagName: "template"
6145	};
6146	const tagName = stringToLowerCase(element.tagName);
6147	const parentTagName = stringToLowerCase(parent.tagName);
6148	if (!ALLOWED_NAMESPACES[element.namespaceURI]) return false;
6149	if (element.namespaceURI === SVG_NAMESPACE) {
6150	if (parent.namespaceURI === HTML_NAMESPACE) return tagName === "svg";
6151	if (parent.namespaceURI === MATHML_NAMESPACE) return tagName === "svg" && (parentTagName === "annotation-xml" \|\| MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
6152	return Boolean(ALL_SVG_TAGS[tagName]);
6153	}
6154	if (element.namespaceURI === MATHML_NAMESPACE) {
6155	if (parent.namespaceURI === HTML_NAMESPACE) return tagName === "math";
6156	if (parent.namespaceURI === SVG_NAMESPACE) return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
6157	return Boolean(ALL_MATHML_TAGS[tagName]);
6158	}
6159	if (element.namespaceURI === HTML_NAMESPACE) {
6160	if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) return false;
6161	if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) return false;
6162	return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] \|\| !ALL_SVG_TAGS[tagName]);
6163	}
6164	if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) return true;
6165	return false;
6166	};
6167	/**
6168	* _forceRemove
6169	*
6170	* @param node a DOM node
6171	*/
6172	const _forceRemove = function _forceRemove(node) {
6173	arrayPush(DOMPurify.removed, { element: node });
6174	try {
6175	getParentNode(node).removeChild(node);
6176	} catch (_) {
6177	remove(node);
6178	}
6179	};
6180	/**
6181	* _removeAttribute
6182	*
6183	* @param name an Attribute name
6184	* @param element a DOM node
6185	*/
6186	const _removeAttribute = function _removeAttribute(name, element) {
6187	try {
6188	arrayPush(DOMPurify.removed, {
6189	attribute: element.getAttributeNode(name),
6190	from: element
6191	});
6192	} catch (_) {
6193	arrayPush(DOMPurify.removed, {
6194	attribute: null,
6195	from: element
6196	});
6197	}
6198	element.removeAttribute(name);
6199	if (name === "is") if (RETURN_DOM \|\| RETURN_DOM_FRAGMENT) try {
6200	_forceRemove(element);
6201	} catch (_) {}
6202	else try {
6203	element.setAttribute(name, "");
6204	} catch (_) {}
6205	};
6206	/**
6207	* _initDocument
6208	*
6209	* @param dirty - a string of dirty markup
6210	* @return a DOM, filled with the dirty markup
6211	*/
6212	const _initDocument = function _initDocument(dirty) {
6213	let doc = null;
6214	let leadingWhitespace = null;
6215	if (FORCE_BODY) dirty = "<remove></remove>" + dirty;
6216	else {
6217	const matches = stringMatch(dirty, /^[\r\n\t ]+/);
6218	leadingWhitespace = matches && matches[0];
6219	}
6220	if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) dirty = "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>" + dirty + "</body></html>";
6221	const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
6222	if (NAMESPACE === HTML_NAMESPACE) try {
6223	doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
6224	} catch (_) {}
6225	if (!doc \|\| !doc.documentElement) {
6226	doc = implementation.createDocument(NAMESPACE, "template", null);
6227	try {
6228	doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
6229	} catch (_) {}
6230	}
6231	const body = doc.body \|\| doc.documentElement;
6232	if (dirty && leadingWhitespace) body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] \|\| null);
6233	if (NAMESPACE === HTML_NAMESPACE) return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
6234	return WHOLE_DOCUMENT ? doc.documentElement : body;
6235	};
6236	/**
6237	* Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
6238	*
6239	* @param root The root element or node to start traversing on.
6240	* @return The created NodeIterator
6241	*/
6242	const _createNodeIterator = function _createNodeIterator(root) {
6243	return createNodeIterator.call(root.ownerDocument \|\| root, root, NodeFilter.SHOW_ELEMENT \| NodeFilter.SHOW_COMMENT \| NodeFilter.SHOW_TEXT \| NodeFilter.SHOW_PROCESSING_INSTRUCTION \| NodeFilter.SHOW_CDATA_SECTION, null);
6244	};
6245	/**
6246	* _isClobbered
6247	*
6248	* @param element element to check for clobbering attacks
6249	* @return true if clobbered, false if safe
6250	*/
6251	const _isClobbered = function _isClobbered(element) {
6252	return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" \|\| typeof element.textContent !== "string" \|\| typeof element.removeChild !== "function" \|\| !(element.attributes instanceof NamedNodeMap) \|\| typeof element.removeAttribute !== "function" \|\| typeof element.setAttribute !== "function" \|\| typeof element.namespaceURI !== "string" \|\| typeof element.insertBefore !== "function" \|\| typeof element.hasChildNodes !== "function");
6253	};
6254	/**
6255	* Checks whether the given object is a DOM node.
6256	*
6257	* @param value object to check whether it's a DOM node
6258	* @return true is object is a DOM node
6259	*/
6260	const _isNode = function _isNode(value) {
6261	return typeof Node === "function" && value instanceof Node;
6262	};
6263	function _executeHooks(hooks, currentNode, data) {
6264	arrayForEach(hooks, (hook) => {
6265	hook.call(DOMPurify, currentNode, data, CONFIG);
6266	});
6267	}
6268	/**
6269	* _sanitizeElements
6270	*
6271	* @protect nodeName
6272	* @protect textContent
6273	* @protect removeChild
6274	* @param currentNode to check for permission to exist
6275	* @return true if node was killed, false if left alive
6276	*/
6277	const _sanitizeElements = function _sanitizeElements(currentNode) {
6278	let content = null;
6279	_executeHooks(hooks.beforeSanitizeElements, currentNode, null);
6280	if (_isClobbered(currentNode)) {
6281	_forceRemove(currentNode);
6282	return true;
6283	}
6284	const tagName = transformCaseFunc(currentNode.nodeName);
6285	_executeHooks(hooks.uponSanitizeElement, currentNode, {
6286	tagName,
6287	allowedTags: ALLOWED_TAGS
6288	});
6289	if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
6290	_forceRemove(currentNode);
6291	return true;
6292	}
6293	if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
6294	_forceRemove(currentNode);
6295	return true;
6296	}
6297	if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
6298	_forceRemove(currentNode);
6299	return true;
6300	}
6301	if (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] \|\| FORBID_TAGS[tagName])) {
6302	if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
6303	if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
6304	if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) return false;
6305	}
6306	if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
6307	const parentNode = getParentNode(currentNode) \|\| currentNode.parentNode;
6308	const childNodes = getChildNodes(currentNode) \|\| currentNode.childNodes;
6309	if (childNodes && parentNode) {
6310	const childCount = childNodes.length;
6311	for (let i = childCount - 1; i >= 0; --i) {
6312	const childClone = cloneNode(childNodes[i], true);
6313	childClone.__removalCount = (currentNode.__removalCount \|\| 0) + 1;
6314	parentNode.insertBefore(childClone, getNextSibling(currentNode));
6315	}
6316	}
6317	}
6318	_forceRemove(currentNode);
6319	return true;
6320	}
6321	if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
6322	_forceRemove(currentNode);
6323	return true;
6324	}
6325	if ((tagName === "noscript" \|\| tagName === "noembed" \|\| tagName === "noframes") && regExpTest(/<\/no(script\|embed\|frames)/i, currentNode.innerHTML)) {
6326	_forceRemove(currentNode);
6327	return true;
6328	}
6329	if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
6330	content = currentNode.textContent;
6331	arrayForEach([
6332	MUSTACHE_EXPR,
6333	ERB_EXPR,
6334	TMPLIT_EXPR
6335	], (expr) => {
6336	content = stringReplace(content, expr, " ");
6337	});
6338	if (currentNode.textContent !== content) {
6339	arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
6340	currentNode.textContent = content;
6341	}
6342	}
6343	_executeHooks(hooks.afterSanitizeElements, currentNode, null);
6344	return false;
6345	};
6346	/**
6347	* _isValidAttribute
6348	*
6349	* @param lcTag Lowercase tag name of containing element.
6350	* @param lcName Lowercase attribute name.
6351	* @param value Attribute value.
6352	* @return Returns true if `value` is valid, otherwise false.
6353	*/
6354	const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
6355	if (SANITIZE_DOM && (lcName === "id" \|\| lcName === "name") && (value in document \|\| value in formElement)) return false;
6356	if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName));
6357	else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName));
6358	else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag));
6359	else if (!ALLOWED_ATTR[lcName] \|\| FORBID_ATTR[lcName]) if (_isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) \|\| CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) \|\| CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName, lcTag)) \|\| lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) \|\| CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value)));
6360	else return false;
6361	else if (URI_SAFE_ATTRIBUTES[lcName]);
6362	else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, "")));
6363	else if ((lcName === "src" \|\| lcName === "xlink:href" \|\| lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]);
6364	else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, "")));
6365	else if (value) return false;
6366	return true;
6367	};
6368	/**
6369	* _isBasicCustomElement
6370	* checks if at least one dash is included in tagName, and it's not the first char
6371	* for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
6372	*
6373	* @param tagName name of the tag of the node to sanitize
6374	* @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
6375	*/
6376	const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
6377	return tagName !== "annotation-xml" && stringMatch(tagName, CUSTOM_ELEMENT);
6378	};
6379	/**
6380	* _sanitizeAttributes
6381	*
6382	* @protect attributes
6383	* @protect nodeName
6384	* @protect removeAttribute
6385	* @protect setAttribute
6386	*
6387	* @param currentNode to sanitize
6388	*/
6389	const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
6390	_executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
6391	const { attributes } = currentNode;
6392	if (!attributes \|\| _isClobbered(currentNode)) return;
6393	const hookEvent = {
6394	attrName: "",
6395	attrValue: "",
6396	keepAttr: true,
6397	allowedAttributes: ALLOWED_ATTR,
6398	forceKeepAttr: void 0
6399	};
6400	let l = attributes.length;
6401	while (l--) {
6402	const { name, namespaceURI, value: attrValue } = attributes[l];
6403	const lcName = transformCaseFunc(name);
6404	const initValue = attrValue;
6405	let value = name === "value" ? initValue : stringTrim(initValue);
6406	hookEvent.attrName = lcName;
6407	hookEvent.attrValue = value;
6408	hookEvent.keepAttr = true;
6409	hookEvent.forceKeepAttr = void 0;
6410	_executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
6411	value = hookEvent.attrValue;
6412	if (SANITIZE_NAMED_PROPS && (lcName === "id" \|\| lcName === "name")) {
6413	_removeAttribute(name, currentNode);
6414	value = SANITIZE_NAMED_PROPS_PREFIX + value;
6415	}
6416	if (SAFE_FOR_XML && regExpTest(/((--!?\|])>)\|<\/(style\|title\|textarea)/i, value)) {
6417	_removeAttribute(name, currentNode);
6418	continue;
6419	}
6420	if (lcName === "attributename" && stringMatch(value, "href")) {
6421	_removeAttribute(name, currentNode);
6422	continue;
6423	}
6424	if (hookEvent.forceKeepAttr) continue;
6425	if (!hookEvent.keepAttr) {
6426	_removeAttribute(name, currentNode);
6427	continue;
6428	}
6429	if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
6430	_removeAttribute(name, currentNode);
6431	continue;
6432	}
6433	if (SAFE_FOR_TEMPLATES) arrayForEach([
6434	MUSTACHE_EXPR,
6435	ERB_EXPR,
6436	TMPLIT_EXPR
6437	], (expr) => {
6438	value = stringReplace(value, expr, " ");
6439	});
6440	const lcTag = transformCaseFunc(currentNode.nodeName);
6441	if (!_isValidAttribute(lcTag, lcName, value)) {
6442	_removeAttribute(name, currentNode);
6443	continue;
6444	}
6445	if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") if (namespaceURI);
6446	else switch (trustedTypes.getAttributeType(lcTag, lcName)) {
6447	case "TrustedHTML":
6448	value = trustedTypesPolicy.createHTML(value);
6449	break;
6450	case "TrustedScriptURL":
6451	value = trustedTypesPolicy.createScriptURL(value);
6452	break;
6453	}
6454	if (value !== initValue) try {
6455	if (namespaceURI) currentNode.setAttributeNS(namespaceURI, name, value);
6456	else currentNode.setAttribute(name, value);
6457	if (_isClobbered(currentNode)) _forceRemove(currentNode);
6458	else arrayPop(DOMPurify.removed);
6459	} catch (_) {
6460	_removeAttribute(name, currentNode);
6461	}
6462	}
6463	_executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
6464	};
6465	/**
6466	* _sanitizeShadowDOM
6467	*
6468	* @param fragment to iterate over recursively
6469	*/
6470	const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
6471	let shadowNode = null;
6472	const shadowIterator = _createNodeIterator(fragment);
6473	_executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
6474	while (shadowNode = shadowIterator.nextNode()) {
6475	_executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
6476	_sanitizeElements(shadowNode);
6477	_sanitizeAttributes(shadowNode);
6478	if (shadowNode.content instanceof DocumentFragment) _sanitizeShadowDOM(shadowNode.content);
6479	}
6480	_executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
6481	};
6482	DOMPurify.sanitize = function(dirty) {
6483	let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
6484	let body = null;
6485	let importedNode = null;
6486	let currentNode = null;
6487	let returnNode = null;
6488	IS_EMPTY_INPUT = !dirty;
6489	if (IS_EMPTY_INPUT) dirty = "<!-->";
6490	if (typeof dirty !== "string" && !_isNode(dirty)) if (typeof dirty.toString === "function") {
6491	dirty = dirty.toString();
6492	if (typeof dirty !== "string") throw typeErrorCreate("dirty is not a string, aborting");
6493	} else throw typeErrorCreate("toString is not a function");
6494	if (!DOMPurify.isSupported) return dirty;
6495	if (!SET_CONFIG) _parseConfig(cfg);
6496	DOMPurify.removed = [];
6497	if (typeof dirty === "string") IN_PLACE = false;
6498	if (IN_PLACE) {
6499	if (dirty.nodeName) {
6500	const tagName = transformCaseFunc(dirty.nodeName);
6501	if (!ALLOWED_TAGS[tagName] \|\| FORBID_TAGS[tagName]) throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
6502	}
6503	} else if (dirty instanceof Node) {
6504	body = _initDocument("<!---->");
6505	importedNode = body.ownerDocument.importNode(dirty, true);
6506	if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === "BODY") body = importedNode;
6507	else if (importedNode.nodeName === "HTML") body = importedNode;
6508	else body.appendChild(importedNode);
6509	} else {
6510	if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf("<") === -1) return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
6511	body = _initDocument(dirty);
6512	if (!body) return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
6513	}
6514	if (body && FORCE_BODY) _forceRemove(body.firstChild);
6515	const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
6516	while (currentNode = nodeIterator.nextNode()) {
6517	_sanitizeElements(currentNode);
6518	_sanitizeAttributes(currentNode);
6519	if (currentNode.content instanceof DocumentFragment) _sanitizeShadowDOM(currentNode.content);
6520	}
6521	if (IN_PLACE) return dirty;
6522	if (RETURN_DOM) {
6523	if (RETURN_DOM_FRAGMENT) {
6524	returnNode = createDocumentFragment.call(body.ownerDocument);
6525	while (body.firstChild) returnNode.appendChild(body.firstChild);
6526	} else returnNode = body;
6527	if (ALLOWED_ATTR.shadowroot \|\| ALLOWED_ATTR.shadowrootmode) returnNode = importNode.call(originalDocument, returnNode, true);
6528	return returnNode;
6529	}
6530	let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
6531	if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
6532	if (SAFE_FOR_TEMPLATES) arrayForEach([
6533	MUSTACHE_EXPR,
6534	ERB_EXPR,
6535	TMPLIT_EXPR
6536	], (expr) => {
6537	serializedHTML = stringReplace(serializedHTML, expr, " ");
6538	});
6539	return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
6540	};
6541	DOMPurify.setConfig = function() {
6542	let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
6543	_parseConfig(cfg);
6544	SET_CONFIG = true;
6545	};
6546	DOMPurify.clearConfig = function() {
6547	CONFIG = null;
6548	SET_CONFIG = false;
6549	};
6550	DOMPurify.isValidAttribute = function(tag, attr, value) {
6551	if (!CONFIG) _parseConfig({});
6552	const lcTag = transformCaseFunc(tag);
6553	const lcName = transformCaseFunc(attr);
6554	return _isValidAttribute(lcTag, lcName, value);
6555	};
6556	DOMPurify.addHook = function(entryPoint, hookFunction) {
6557	if (typeof hookFunction !== "function") return;
6558	arrayPush(hooks[entryPoint], hookFunction);
6559	};
6560	DOMPurify.removeHook = function(entryPoint, hookFunction) {
6561	if (hookFunction !== void 0) {
6562	const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
6563	return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
6564	}
6565	return arrayPop(hooks[entryPoint]);
6566	};
6567	DOMPurify.removeHooks = function(entryPoint) {
6568	hooks[entryPoint] = [];
6569	};
6570	DOMPurify.removeAllHooks = function() {
6571	hooks = _createHooksMap();
6572	};
6573	return DOMPurify;
6574	}
6575	var purify = createDOMPurify();
6576
6577	//#endregion
6578	//#region packages/packages/core/editor-canvas/src/utils/sanitize-escaped-html.ts
6579	var ALLOWED_NON_OPERATIONAL_ATTRS = [
6580	"href",
6581	"target",
6582	"class",
6583	"id",
6584	"style",
6585	"title",
6586	"lang",
6587	"dir",
6588	"role"
6589	];
6590	function getAllowedHtmlWrapperTags$1() {
6591	return window.elementorCommon?.config?.allowedHTMLWrapperTags ?? [];
6592	}
6593	__name(getAllowedHtmlWrapperTags$1, "getAllowedHtmlWrapperTags");
6594	function sanitizeEscapedHtml(value) {
6595	if (!value) return "";
6596	const allowedTags = [...getAllowedHtmlWrapperTags$1()];
6597	return purify.sanitize(value, {
6598	ALLOWED_TAGS: allowedTags,
6599	ALLOWED_ATTR: [...ALLOWED_NON_OPERATIONAL_ATTRS],
6600	ALLOW_DATA_ATTR: true,
6601	ALLOW_ARIA_ATTR: true
6602	});
6603	}
6604
6605	//#endregion
6606	//#region packages/packages/core/editor-canvas/src/transformers/settings/escaped-html-transformer.ts
6607	var escapedHtmlTransformer = createTransformer((value) => {
6608	return sanitizeEscapedHtml(value);
6609	});
6610
6611	//#endregion
6612	//#region packages/packages/core/editor-canvas/src/transformers/settings/html-v2-transformer.ts
6613	var htmlV2Transformer = createTransformer((value) => {
6614	return value?.content ?? "";
6615	});
6616
6617	//#endregion
6618	//#region packages/packages/core/editor-canvas/src/transformers/settings/html-v3-transformer.ts
6619	var htmlV3Transformer = createTransformer((value) => {
6620	return value?.content ?? "";
6621	});
6622
6623	//#endregion
6624	//#region packages/packages/core/editor-canvas/src/transformers/settings/link-transformer.ts
6625	var linkTransformer = createTransformer(({ destination, isTargetBlank, tag }) => {
6626	return {
6627	href: typeof destination === "number" ? "#post-id-" + destination : destination,
6628	target: isTargetBlank ? "_blank" : "_self",
6629	tag: tag ?? "a"
6630	};
6631	});
6632
6633	//#endregion
6634	//#region packages/packages/core/editor-canvas/src/transformers/settings/query-transformer.ts
6635	var queryTransformer = createTransformer(({ id }) => {
6636	return id ?? null;
6637	});
6638
6639	//#endregion
6640	//#region packages/packages/core/editor-canvas/src/transformers/settings/time-range-transformer.ts
6641	var timeRangeTransformer = createTransformer((value) => {
6642	if (!value \|\| Object.keys(value).length === 0) return null;
6643	return {
6644	min: value.min \|\| null,
6645	max: value.max \|\| null
6646	};
6647	});
6648
6649	//#endregion
6650	//#region packages/packages/core/editor-canvas/src/transformers/shared/process-svg-content.ts
6651	var SVG_INLINE_STYLES = "width: 100%; height: 100%; overflow: unset;";
6652	function processSvgContent(svgText) {
6653	const sanitized = purify.sanitize(svgText, { USE_PROFILES: {
6654	svg: true,
6655	svgFilters: true
6656	} });
6657	const svgElement = new DOMParser().parseFromString(sanitized, "image/svg+xml").querySelector("svg");
6658	if (!svgElement) return null;
6659	svgElement.setAttribute("fill", "currentColor");
6660	const trimmed = (svgElement.getAttribute("style") ?? "").trim();
6661	const merged = trimmed ? `${trimmed.replace(/;$/, "")}; ${SVG_INLINE_STYLES}` : SVG_INLINE_STYLES;
6662	svgElement.setAttribute("style", merged);
6663	return svgElement.outerHTML;
6664	}
6665
6666	//#endregion
6667	//#region packages/packages/core/editor-canvas/src/transformers/shared/icon-transformer.ts
6668	var FONT_AWESOME_JSON = {
6669	width: 0,
6670	height: 1,
6671	path: 4
6672	};
6673	var fontAwesomeJsonCache = /* @__PURE__ */ new Map();
6674	var iconTransformer = createTransformer(async (value, { signal }) => {
6675	const iconValue = typeof value.value === "string" ? value.value : null;
6676	const library = typeof value.library === "string" ? value.library : null;
6677	if (!iconValue \|\| !library) return {
6678	html: null,
6679	url: null
6680	};
6681	const iconName = getFontAwesomeIconName(iconValue);
6682	const jsonFileName = getFontAwesomeJsonFileName(library);
6683	if (!iconName \|\| !jsonFileName) return {
6684	html: null,
6685	url: null
6686	};
6687	const iconData = (await fetchFontAwesomeIcons(jsonFileName, signal))?.[iconName];
6688	if (!iconData) return {
6689	html: null,
6690	url: null
6691	};
6692	return {
6693	html: processSvgContent(buildFontAwesomeSvg(iconData)),
6694	url: null
6695	};
6696	});
6697	function getFontAwesomeIconName(iconValue) {
6698	return iconValue.match(/^fa\S*\s+fa-(.+)$/)?.[1] ?? null;
6699	}
6700	function getFontAwesomeJsonFileName(library) {
6701	if (!library.startsWith("fa-")) return null;
6702	return library.replace(/^fa-/, "");
6703	}
6704	function getAssetsBaseUrl() {
6705	const assetsUrl = window.elementorCommon?.config?.urls?.assets;
6706	return typeof assetsUrl === "string" && assetsUrl !== "" ? assetsUrl : null;
6707	}
6708	async function fetchFontAwesomeIcons(jsonFileName, signal) {
6709	const cached = fontAwesomeJsonCache.get(jsonFileName);
6710	if (cached) return cached;
6711	const icons = await loadFontAwesomeIcons(jsonFileName, signal);
6712	if (icons) fontAwesomeJsonCache.set(jsonFileName, icons);
6713	return icons;
6714	}
6715	async function loadFontAwesomeIcons(jsonFileName, signal) {
6716	const assetsUrl = getAssetsBaseUrl();
6717	if (!assetsUrl) return null;
6718	try {
6719	const response = await fetch(`${assetsUrl}lib/font-awesome/json/${jsonFileName}.json`, { signal });
6720	if (!response.ok) return null;
6721	return (await response.json()).icons ?? null;
6722	} catch {
6723	return null;
6724	}
6725	}
6726	function buildFontAwesomeSvg(iconData) {
6727	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${iconData[FONT_AWESOME_JSON.width]} ${iconData[FONT_AWESOME_JSON.height]}"><path d="${iconData[FONT_AWESOME_JSON.path]}"></path></svg>`;
6728	}
6729
6730	//#endregion
6731	//#region packages/packages/core/editor-canvas/src/transformers/shared/image-src-transformer.ts
6732	var imageSrcTransformer = createTransformer((value) => ({
6733	id: value.id ?? null,
6734	url: value.url ?? null,
6735	alt: value.alt ?? null
6736	}));
6737
6738	//#endregion
6739	//#region packages/packages/core/editor-canvas/src/transformers/shared/image-transformer.ts
6740	var imageTransformer = createTransformer(async (value) => {
6741	const { src, size } = value;
6742	if (!src?.id) return src?.url ? {
6743	src: src.url,
6744	alt: src.alt ?? ""
6745	} : null;
6746	const attachment = await (0, _elementor_wp_media.getMediaAttachment)({ id: src.id });
6747	const sizedAttachment = attachment?.sizes?.[size ?? ""];
6748	if (sizedAttachment) return {
6749	src: sizedAttachment.url,
6750	height: sizedAttachment.height,
6751	width: sizedAttachment.width,
6752	alt: attachment.alt
6753	};
6754	if (attachment) return {
6755	src: attachment.url,
6756	height: attachment.height,
6757	width: attachment.width,
6758	alt: attachment.alt
6759	};
6760	return null;
6761	});
6762
6763	//#endregion
6764	//#region packages/packages/core/editor-canvas/src/transformers/shared/plain-transformer.ts
6765	var plainTransformer = createTransformer((value) => {
6766	return value;
6767	});
6768
6769	//#endregion
6770	//#region packages/packages/core/editor-canvas/src/transformers/shared/svg-src-transformer.ts
6771	async function fetchSvgContent(url, signal) {
6772	try {
6773	const response = await fetch(url, { signal });
6774	if (!response.ok) return null;
6775	const contentType = response.headers.get("content-type") ?? "";
6776	if (!(contentType.includes("svg") \|\| contentType.includes("xml") \|\| url.endsWith(".svg"))) return null;
6777	return await response.text();
6778	} catch {
6779	return null;
6780	}
6781	}
6782	function resolveSvgSrcId(id) {
6783	if (typeof id !== "number" \|\| id <= 0) return null;
6784	return id;
6785	}
6786	var svgSrcTransformer = createTransformer(async (value, { signal }) => {
6787	const id = resolveSvgSrcId(value.id);
6788	const urlFromValue = typeof value.url === "string" ? value.url : null;
6789	let url = urlFromValue;
6790	if (id && !urlFromValue) url = (await (0, _elementor_wp_media.getMediaAttachment)({ id }))?.url ?? null;
6791	const resolvedUrl = typeof url === "string" ? url : null;
6792	if (!resolvedUrl) return {
6793	html: null,
6794	url: null
6795	};
6796	const svgText = await fetchSvgContent(resolvedUrl, signal);
6797	return {
6798	html: svgText ? processSvgContent(svgText) : null,
6799	url: resolvedUrl
6800	};
6801	});
6802
6803	//#endregion
6804	//#region packages/packages/core/editor-canvas/src/transformers/shared/video-src-transformer.ts
6805	var videoSrcTransformer = createTransformer(async (value) => {
6806	const { id, url } = value;
6807	if (!id) return {
6808	id: null,
6809	url
6810	};
6811	return {
6812	id,
6813	url: (await (0, _elementor_wp_media.getMediaAttachment)({ id }))?.url ?? url
6814	};
6815	});
6816
6817	//#endregion
6818	//#region packages/packages/core/editor-canvas/src/init-settings-transformers.ts
6819	function initSettingsTransformers() {
6820	settingsTransformersRegistry.register("classes", createClassesTransformer()).register("link", linkTransformer).register("query", queryTransformer).register("image", imageTransformer).register("image-src", imageSrcTransformer).register("svg-src", svgSrcTransformer).register("icon", iconTransformer).register("video-src", videoSrcTransformer).register("attributes", attributesTransformer).register("date-time", dateTimeTransformer).register("html-v2", htmlV2Transformer).register("html-v3", htmlV3Transformer).register("escaped-html", escapedHtmlTransformer).register("date-range", dateRangeTransformer).register("time-range", timeRangeTransformer).registerFallback(plainTransformer);
6821	}
6822
6823	//#endregion
6824	//#region packages/packages/core/editor-canvas/src/transformers/styles/background-color-overlay-transformer.ts
6825	var backgroundColorOverlayTransformer = createTransformer((value) => {
6826	const { color = null } = value;
6827	if (!color) return null;
6828	return `linear-gradient(${color}, ${color})`;
6829	});
6830
6831	//#endregion
6832	//#region packages/packages/core/editor-canvas/src/transformers/styles/background-gradient-overlay-transformer.ts
6833	var backgroundGradientOverlayTransformer = createTransformer((value) => {
6834	if (value.type === "radial") return `radial-gradient(circle at ${value.positions}, ${value.stops})`;
6835	return `linear-gradient(${value.angle}deg, ${value.stops})`;
6836	});
6837
6838	//#endregion
6839	//#region packages/packages/core/editor-canvas/src/transformers/styles/background-image-overlay-transformer.ts
6840	var backgroundImageOverlayTransformer = createTransformer((value) => {
6841	const { image, size = null, position = null, repeat = null, attachment = null } = value;
6842	if (!image) return null;
6843	return {
6844	src: image.src ? `url(${image.src})` : null,
6845	repeat,
6846	attachment,
6847	size,
6848	position
6849	};
6850	});
6851
6852	//#endregion
6853	//#region packages/packages/core/editor-canvas/src/transformers/styles/background-image-size-scale-transformer.ts
6854	var backgroundImageSizeScaleTransformer = createTransformer(({ width, height }) => `${width ?? "auto"} ${height ?? "auto"}`);
6855
6856	//#endregion
6857	//#region packages/packages/core/editor-canvas/src/transformers/styles/background-overlay-transformer.ts
6858	var backgroundOverlayTransformer = createTransformer((value) => {
6859	if (!value \|\| value.length === 0) return null;
6860	const normalizedValues = normalizeOverlayValues(value);
6861	if (normalizedValues.length === 0) return null;
6862	return {
6863	"background-image": getValuesString(normalizedValues, "src", "none", true),
6864	"background-repeat": getValuesString(normalizedValues, "repeat", "repeat"),
6865	"background-attachment": getValuesString(normalizedValues, "attachment", "scroll"),
6866	"background-size": getValuesString(normalizedValues, "size", "auto auto"),
6867	"background-position": getValuesString(normalizedValues, "position", "0% 0%")
6868	};
6869	});
6870	function normalizeOverlayValues(overlays) {
6871	return overlays.map((item) => {
6872	if (typeof item === "string") return {
6873	src: item,
6874	repeat: null,
6875	attachment: null,
6876	size: null,
6877	position: null
6878	};
6879	return item;
6880	}).filter((item) => item && !!item.src);
6881	}
6882	function getValuesString(items, prop, defaultValue, preventUnification = false) {
6883	if (items.filter((item) => item?.[prop]).length === 0) return defaultValue;
6884	const formattedValues = items.map((item) => item[prop] ?? defaultValue);
6885	if (!preventUnification) {
6886	if (formattedValues.every((value) => value === formattedValues[0])) return formattedValues[0];
6887	}
6888	return formattedValues.join(",");
6889	}
6890
6891	//#endregion
6892	//#region packages/packages/core/editor-canvas/src/transformers/styles/background-transformer.ts
6893	var backgroundTransformer = createTransformer((value) => {
6894	const { color = null, "background-overlay": overlays = null, clip = null } = value;
6895	return createMultiPropsValue({
6896	...overlays,
6897	"background-color": color,
6898	"background-clip": clip
6899	});
6900	});
6901
6902	//#endregion
6903	//#region packages/packages/core/editor-canvas/src/transformers/styles/color-stop-transformer.ts
6904	var colorStopTransformer = createTransformer((value) => `${value?.color} ${value?.offset ?? 0}%`);
6905
6906	//#endregion
6907	//#region packages/packages/core/editor-canvas/src/transformers/styles/create-combine-array-transformer.ts
6908	var createCombineArrayTransformer = (delimiter) => {
6909	return createTransformer((value) => value?.length ? value.filter(Boolean).join(delimiter) : null);
6910	};
6911
6912	//#endregion
6913	//#region packages/packages/core/editor-canvas/src/transformers/styles/create-multi-props-transformer.ts
6914	var createMultiPropsTransformer = (keys, keyGenerator) => {
6915	return createTransformer((value, { key: propKey }) => {
6916	const entries = keys.filter((key) => value[key]).map((key) => [keyGenerator({
6917	propKey,
6918	key
6919	}), value[key]]);
6920	return createMultiPropsValue(Object.fromEntries(entries));
6921	});
6922	};
6923
6924	//#endregion
6925	//#region packages/packages/core/editor-canvas/src/transformers/styles/filter-transformer.ts
6926	var filterTransformer = createTransformer((filterValues) => {
6927	if (filterValues?.length < 1) return null;
6928	return filterValues.filter(Boolean).map(mapToFilterFunctionString).join(" ");
6929	});
6930	var mapToFilterFunctionString = (value) => {
6931	if (value.func === "drop-shadow") {
6932	const { xAxis, yAxis, blur, color } = value.args;
6933	return `drop-shadow(${xAxis \|\| "0px"} ${yAxis \|\| "0px"} ${blur \|\| "10px"} ${color \|\| "transparent"})`;
6934	}
6935	const size = value.args?.size;
6936	if (!value.func \|\| !size) return "";
6937	return `${value.func}(${size})`;
6938	};
6939
6940	//#endregion
6941	//#region packages/packages/core/editor-canvas/src/transformers/styles/flex-transformer.ts
6942	var DEFAULT_FLEX_GROW = 0;
6943	var DEFAULT_FLEX_SHRINK = 1;
6944	var DEFAULT_FLEX_BASIS = "auto";
6945	var formatBasis = (basis) => typeof basis === "object" && basis.size !== void 0 ? `${basis.size}${basis.unit \|\| ""}` : basis;
6946	var flexTransformer = createTransformer((value) => {
6947	const grow = value.flexGrow;
6948	const shrink = value.flexShrink;
6949	const basis = value.flexBasis;
6950	const hasGrow = grow !== void 0 && grow !== null;
6951	const hasShrink = shrink !== void 0 && shrink !== null;
6952	const hasBasis = basis !== void 0 && basis !== null;
6953	if (!hasGrow && !hasShrink && !hasBasis) return null;
6954	return `${hasGrow ? grow : DEFAULT_FLEX_GROW} ${hasShrink ? shrink : DEFAULT_FLEX_SHRINK} ${hasBasis ? formatBasis(basis) : DEFAULT_FLEX_BASIS}`;
6955	});
6956
6957	//#endregion
6958	//#region packages/packages/core/editor-canvas/src/transformers/styles/font-family-transformer.ts
6959	var fontFamilyTransformer = createTransformer((value) => {
6960	if (typeof value !== "string" \|\| !value.trim()) return null;
6961	const trimmed = value.trim();
6962	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") \|\| trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed;
6963	return `"${trimmed}"`;
6964	});
6965
6966	//#endregion
6967	//#region packages/packages/core/editor-canvas/src/transformers/styles/grid-track-renderer.ts
6968	var GRID_TRACK_PROPERTIES = /* @__PURE__ */ new Set(["grid-template-columns", "grid-template-rows"]);
6969	var isGridTrackProperty = (cssProperty) => GRID_TRACK_PROPERTIES.has(cssProperty);
6970	var formatGridTrackRepeat = (count) => {
6971	if (!Number.isFinite(count) \|\| count < 1) return null;
6972	return `repeat(${count}, 1fr)`;
6973	};
6974
6975	//#endregion
6976	//#region packages/packages/core/editor-canvas/src/transformers/styles/grid-track-size-transformer.ts
6977	var gridTrackSizeTransformer = createTransformer((value) => {
6978	if (value.unit === "custom") return value.size;
6979	if (value.unit === "fr") return formatGridTrackRepeat(Math.trunc(Number(value.size)));
6980	return `${value.size}${value.unit}`;
6981	});
6982
6983	//#endregion
6984	//#region packages/packages/core/editor-canvas/src/transformers/styles/perspective-origin-transformer.ts
6985	var FALLBACK = "0px";
6986	function getVal$1(val) {
6987	return `${val ?? FALLBACK}`;
6988	}
6989	__name(getVal$1, "getVal");
6990	var perspectiveOriginTransformer = createTransformer((value) => `${getVal$1(value?.x)} ${getVal$1(value?.y)}`);
6991
6992	//#endregion
6993	//#region packages/packages/core/editor-canvas/src/transformers/styles/position-transformer.ts
6994	var positionTransformer = createTransformer(({ x, y }) => `${x ?? "0px"} ${y ?? "0px"}`);
6995
6996	//#endregion
6997	//#region packages/packages/core/editor-canvas/src/transformers/styles/shadow-transformer.ts
6998	var shadowTransformer = createTransformer((value) => {
6999	return [
7000	value.hOffset,
7001	value.vOffset,
7002	value.blur,
7003	value.spread,
7004	value.color,
7005	value.position
7006	].filter(Boolean).join(" ");
7007	});
7008
7009	//#endregion
7010	//#region packages/packages/core/editor-canvas/src/transformers/styles/size-transformer.ts
7011	var sizeTransformer = createTransformer((value) => {
7012	if (value.unit === "auto") return "auto";
7013	return value.unit === "custom" ? value.size : `${value.size}${value.unit}`;
7014	});
7015
7016	//#endregion
7017	//#region packages/packages/core/editor-canvas/src/transformers/styles/span-transformer.ts
7018	var spanTransformer = createTransformer((value) => {
7019	return value?.trim() \|\| null;
7020	});
7021
7022	//#endregion
7023	//#region packages/packages/core/editor-canvas/src/transformers/styles/stroke-transformer.ts
7024	var strokeTransformer = createTransformer((value) => {
7025	return createMultiPropsValue({
7026	"-webkit-text-stroke": `${value.width} ${value.color}`,
7027	stroke: `${value.color}`,
7028	"stroke-width": `${value.width}`
7029	});
7030	});
7031
7032	//#endregion
7033	//#region packages/packages/core/editor-canvas/src/transformers/styles/transform-functions-transformer.ts
7034	var transformFunctionsTransformer = createTransformer((values) => {
7035	if (values?.length < 1) return null;
7036	return values.join(" ");
7037	});
7038
7039	//#endregion
7040	//#region packages/packages/core/editor-canvas/src/transformers/styles/transform-move-transformer.ts
7041	var defaultMove = "0px";
7042	var transformMoveTransformer = createTransformer((value) => {
7043	return `translate3d(${value.x ?? defaultMove}, ${value.y ?? defaultMove}, ${value.z ?? defaultMove})`;
7044	});
7045
7046	//#endregion
7047	//#region packages/packages/core/editor-canvas/src/transformers/styles/transform-origin-transformer.ts
7048	var EMPTY_VALUE = "0px";
7049	var DEFAULT_XY = "50%";
7050	var DEFAULT_Z = EMPTY_VALUE;
7051	function getVal(val) {
7052	return `${val ?? EMPTY_VALUE}`;
7053	}
7054	var transformOriginTransformer = createTransformer((value) => {
7055	const x = getVal(value.x);
7056	const y = getVal(value.y);
7057	const z = getVal(value.z);
7058	if (x === DEFAULT_XY && y === DEFAULT_XY && z === DEFAULT_Z) return null;
7059	return `${x} ${y} ${z}`;
7060	});
7061
7062	//#endregion
7063	//#region packages/packages/core/editor-canvas/src/transformers/styles/transform-rotate-transformer.ts
7064	var defaultRotate = "0deg";
7065	var transformRotateTransformer = createTransformer((value) => {
7066	return [
7067	`rotateX(${value?.x ?? defaultRotate})`,
7068	`rotateY(${value?.y ?? defaultRotate})`,
7069	`rotateZ(${value?.z ?? defaultRotate})`
7070	].join(" ");
7071	});
7072
7073	//#endregion
7074	//#region packages/packages/core/editor-canvas/src/transformers/styles/transform-scale-transformer.ts
7075	var transformScaleTransformer = createTransformer((value) => {
7076	return `scale3d(${value.x ?? 1}, ${value.y ?? 1}, ${value.z ?? 1})`;
7077	});
7078
7079	//#endregion
7080	//#region packages/packages/core/editor-canvas/src/transformers/styles/transform-skew-transformer.ts
7081	var defaultSkew = "0deg";
7082	var transformSkewTransformer = createTransformer((value) => {
7083	return `skew(${value?.x ?? defaultSkew}, ${value?.y ?? defaultSkew})`;
7084	});
7085
7086	//#endregion
7087	//#region packages/packages/core/editor-canvas/src/transformers/styles/transition-transformer.ts
7088	var getAllowedProperties = () => {
7089	const allowedProperties = /* @__PURE__ */ new Set();
7090	_elementor_editor_controls.transitionProperties.forEach((category) => {
7091	category.properties.forEach((property) => {
7092	allowedProperties.add(property.value);
7093	});
7094	});
7095	return allowedProperties;
7096	};
7097	var transitionTransformer = createTransformer((transitionValues) => {
7098	if (transitionValues?.length < 1) return null;
7099	const allowedProperties = getAllowedProperties();
7100	const validTransitions = transitionValues.map((value) => mapToTransitionString(value, allowedProperties)).filter(Boolean);
7101	if (validTransitions.length === 0) return null;
7102	return validTransitions.join(", ");
7103	});
7104	var mapToTransitionString = (value, allowedProperties) => {
7105	if (!value.selection \|\| !value.size) return "";
7106	const property = value.selection.value;
7107	if (!allowedProperties.has(property)) return "";
7108	return `${property} ${value.size}`;
7109	};
7110
7111	//#endregion
7112	//#region packages/packages/core/editor-canvas/src/init-style-transformers.ts
7113	function initStyleTransformers() {
7114	styleTransformersRegistry.register("font-family", fontFamilyTransformer).register("size", sizeTransformer).register("grid-track-size", gridTrackSizeTransformer).register("shadow", shadowTransformer).register("stroke", strokeTransformer).register("dimensions", createMultiPropsTransformer([
7115	"block-start",
7116	"block-end",
7117	"inline-start",
7118	"inline-end"
7119	], ({ propKey, key }) => `${propKey}-${key}`)).register("filter", filterTransformer).register("backdrop-filter", filterTransformer).register("box-shadow", createCombineArrayTransformer(",")).register("background", backgroundTransformer).register("background-overlay", backgroundOverlayTransformer).register("background-color-overlay", backgroundColorOverlayTransformer).register("background-image-overlay", backgroundImageOverlayTransformer).register("background-gradient-overlay", backgroundGradientOverlayTransformer).register("gradient-color-stop", createCombineArrayTransformer(",")).register("color-stop", colorStopTransformer).register("background-image-position-offset", positionTransformer).register("background-image-size-scale", backgroundImageSizeScaleTransformer).register("image-src", imageSrcTransformer).register("image", imageTransformer).register("object-position", positionTransformer).register("span", spanTransformer).register("transform-origin", transformOriginTransformer).register("perspective-origin", perspectiveOriginTransformer).register("transform-move", transformMoveTransformer).register("transform-scale", transformScaleTransformer).register("transform-rotate", transformRotateTransformer).register("transform-skew", transformSkewTransformer).register("transform-functions", transformFunctionsTransformer).register("transform", createMultiPropsTransformer([
7120	"transform-functions",
7121	"transform-origin",
7122	"perspective",
7123	"perspective-origin"
7124	], ({ key }) => key === "transform-functions" ? "transform" : key)).register("transition", transitionTransformer).register("layout-direction", createMultiPropsTransformer(["row", "column"], ({ propKey, key }) => `${key}-${propKey}`)).register("flex", flexTransformer).register("border-width-v2", createMultiPropsTransformer([
7125	"block-start",
7126	"block-end",
7127	"inline-start",
7128	"inline-end"
7129	], ({ key }) => `border-${key}-width`)).register("border-radius-v2", createMultiPropsTransformer([
7130	"start-start",
7131	"start-end",
7132	"end-start",
7133	"end-end"
7134	], ({ key }) => `border-${key}-radius`)).registerFallback(plainTransformer);
7135	}
7136
7137	//#endregion
7138	//#region packages/packages/core/editor-canvas/src/renderers/create-dom-renderer.ts
7139	function createDomRenderer() {
7140	const loader = (0, _elementor_twing.createArrayLoader)({});
7141	const environment = (0, _elementor_twing.createEnvironment)(loader);
7142	environment.registerEscapingStrategy(escapeHtmlTag, "html_tag");
7143	environment.registerEscapingStrategy(escapeURL, "full_url");
7144	return {
7145	register: loader.setTemplate,
7146	render: environment.render
7147	};
7148	}
7149	function getAllowedHtmlWrapperTags() {
7150	return window.elementorCommon?.config?.allowedHTMLWrapperTags ?? [];
7151	}
7152	function escapeHtmlTag(value) {
7153	const allowedTags = getAllowedHtmlWrapperTags();
7154	const normalizedTag = value?.toLowerCase?.() ?? "";
7155	return allowedTags.includes(normalizedTag) ? value : "div";
7156	}
7157	function escapeURL(value) {
7158	const allowedProtocols = [
7159	"http:",
7160	"https:",
7161	"mailto:",
7162	"tel:"
7163	];
7164	try {
7165	const parsed = new URL(value);
7166	return allowedProtocols.includes(parsed.protocol) ? value : "";
7167	} catch {
7168	return "";
7169	}
7170	}
7171
7172	//#endregion
7173	//#region packages/packages/core/editor-canvas/src/legacy/create-element-type.ts
7174	var __typeError$1 = /* @__PURE__ */ __name((msg) => {
7175	throw TypeError(msg);
7176	}, "__typeError");
7177	var __accessCheck$1 = /* @__PURE__ */ __name((obj, member, msg) => member.has(obj) \|\| __typeError$1("Cannot " + msg), "__accessCheck");
7178	var __privateAdd$1 = /* @__PURE__ */ __name((obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value), "__privateAdd");
7179	var __privateMethod$1 = /* @__PURE__ */ __name((obj, member, method) => (__accessCheck$1(obj, member, "access private method"), method), "__privateMethod");
7180	function createElementType(type) {
7181	const legacyWindow = window;
7182	return class extends legacyWindow.elementor.modules.elements.types.Widget {
7183	getType() {
7184	return type;
7185	}
7186	getView() {
7187	return createElementViewClassDeclaration();
7188	}
7189	};
7190	}
7191	function createElementViewClassDeclaration() {
7192	var _instances;
7193	var dispatchEvent_fn;
7194	var dispatchPreviewEvent_fn;
7195	var _a;
7196	const legacyWindow = window;
7197	return _a = class extends legacyWindow.elementor.modules.elements.views.Widget {
7198	constructor() {
7199	super(...arguments);
7200	__privateAdd$1(this, _instances);
7201	}
7202	onRender(...args) {
7203	super.onRender(...args);
7204	__privateMethod$1(this, _instances, dispatchEvent_fn).call(this, "elementor/preview/atomic-widget/render");
7205	__privateMethod$1(this, _instances, dispatchPreviewEvent_fn).call(this, "elementor/element/render");
7206	}
7207	onDestroy(...args) {
7208	super.onDestroy(...args);
7209	__privateMethod$1(this, _instances, dispatchEvent_fn).call(this, "elementor/preview/atomic-widget/destroy");
7210	__privateMethod$1(this, _instances, dispatchPreviewEvent_fn).call(this, "elementor/element/destroy");
7211	}
7212	attributes() {
7213	return {
7214	...super.attributes(),
7215	"data-atomic": "",
7216	style: "display: contents !important;"
7217	};
7218	}
7219	behaviors() {
7220	const disabledBehaviors = [
7221	"InlineEditing",
7222	"Draggable",
7223	"Resizable"
7224	];
7225	const behaviorsAsEntries = Object.entries(super.behaviors()).filter(([key]) => !disabledBehaviors.includes(key));
7226	return Object.fromEntries(behaviorsAsEntries);
7227	}
7228	getDomElement() {
7229	return this.$el.find(":first-child");
7230	}
7231	getHandlesOverlay() {
7232	return null;
7233	}
7234	getContextMenuGroups() {
7235	return super.getContextMenuGroups().filter((group) => group.name !== "save");
7236	}
7237	}, _instances = /* @__PURE__ */ new WeakSet(), dispatchEvent_fn = function(eventType) {
7238	window.top?.dispatchEvent(new CustomEvent(eventType, { detail: { id: this.model.get("id") } }));
7239	}, dispatchPreviewEvent_fn = function(eventType) {
7240	const element = this.getDomElement().get(0);
7241	if (!element) return;
7242	legacyWindow.elementor?.$preview?.[0]?.contentWindow.dispatchEvent(new CustomEvent(eventType, { detail: {
7243	id: this.model.get("id"),
7244	type: this.model.get("widgetType"),
7245	element
7246	} }));
7247	}, _a;
7248	}
7249
7250	//#endregion
7251	//#region packages/packages/core/editor-canvas/src/renderers/compute-html-tag.ts
7252	var DEFAULT_LINK_TAG = "a";
7253	function computeHtmlTag(settings, defaultTag, options = {}) {
7254	if ((options.followLink ?? true) && settingsHaveActiveLink(settings)) {
7255	const link = settings.link;
7256	return extractLinkHtmlTag(isRecord(link) ? link : {});
7257	}
7258	const settingsTag = extractHtmlTagValue(settings.tag);
7259	if (null !== settingsTag && "" !== settingsTag) return settingsTag;
7260	return defaultTag;
7261	}
7262	function settingsHaveActiveLink(settings) {
7263	const link = settings.link;
7264	if (!isRecord(link)) return false;
7265	const href = extractHtmlTagValue(link.href);
7266	if (null !== href && "" !== href) return true;
7267	const attributes = link.attributes;
7268	return typeof attributes === "string" && "" !== attributes;
7269	}
7270	function extractLinkHtmlTag(link) {
7271	const tag = extractHtmlTagValue(link.tag);
7272	if (null !== tag && "" !== tag) return tag;
7273	return "a";
7274	}
7275	function extractHtmlTagValue(value) {
7276	if (isRecord(value) && typeof value.value === "string") return value.value;
7277	if (typeof value === "string") return value;
7278	return null;
7279	}
7280	function isRecord(value) {
7281	return typeof value === "object" && null !== value && !Array.isArray(value);
7282	}
7283
7284	//#endregion
7285	//#region packages/packages/core/editor-canvas/src/legacy/create-pending-element.ts
7286	function createPendingElement(wrapperView, data, options = {}) {
7287	const parentContainer = wrapperView.getContainer();
7288	const model = { ...data };
7289	if (!model.id) model.id = (0, _elementor_editor_elements.generateElementId)();
7290	if (!model.elements) model.elements = [];
7291	if (!(0, _elementor_editor_elements.addModelToParent)(parentContainer.id, model, options)) return;
7292	const childId = model.id;
7293	const childModel = (0, _elementor_editor_elements.findModelInDocument)(childId);
7294	if (!childModel) return;
7295	const pendingContainer = {
7296	id: childId,
7297	settings: {
7298	get: () => ({}),
7299	set: () => ({}),
7300	toJSON: () => ({})
7301	},
7302	parent: parentContainer,
7303	model: childModel,
7304	view: void 0,
7305	lookup() {
7306	return (0, _elementor_editor_elements.getContainer)(childId) ?? pendingContainer;
7307	}
7308	};
7309	wrapperView.once("render", () => {
7310	wrapperView.model?.trigger?.("navigator:add", childModel, options);
7311	});
7312	if (options.edit !== false) selectChildWhenWrapperRenders(wrapperView, childId);
7313	return { getContainer: () => pendingContainer };
7314	}
7315	function selectChildWhenWrapperRenders(wrapperView, childId) {
7316	wrapperView.once("render", () => {
7317	const childContainer = (0, _elementor_editor_elements.getContainer)(childId);
7318	if (childContainer?.model?.trigger) {
7319	childContainer.model.trigger("request:edit");
7320	return;
7321	}
7322	wrapperView.model?.trigger?.("request:edit");
7323	});
7324	}
7325
7326	//#endregion
7327	//#region packages/packages/core/editor-canvas/src/legacy/twig-rendering-utils.ts
7328	function setupTwigRenderer({ renderer, element }) {
7329	const templateKey = element.twig_main_template;
7330	const baseStylesDictionary = element.base_styles_dictionary;
7331	Object.entries(element.twig_templates).forEach(([key, template]) => {
7332	renderer.register(key, template);
7333	});
7334	return {
7335	templateKey,
7336	baseStylesDictionary,
7337	resolveProps: createPropsResolver({
7338	transformers: settingsTransformersRegistry,
7339	schema: element.atomic_props_schema
7340	}),
7341	defaultHtmlTag: element.default_html_tag ?? "div",
7342	htmlTagFollowsLink: element.html_tag_follows_link ?? true
7343	};
7344	}
7345	function createBeforeRender(view) {
7346	view._ensureViewIsIntact();
7347	view._isRendering = true;
7348	view.resetChildViewContainer();
7349	view.triggerMethod("before:render", view);
7350	}
7351	function createAfterRender(view) {
7352	view._isRendering = false;
7353	view.isRendered = true;
7354	view.triggerMethod("render", view);
7355	}
7356	function rerenderExistingChildren(view) {
7357	view.children?.each((childView) => {
7358	childView.render();
7359	});
7360	}
7361	async function waitForChildrenToComplete(view) {
7362	const promises = [];
7363	view.children?.each((childView) => {
7364	if (childView._currentRenderPromise) promises.push(childView._currentRenderPromise);
7365	});
7366	if (promises.length > 0) await Promise.all(promises);
7367	}
7368
7369	//#endregion
7370	//#region packages/packages/core/editor-canvas/src/legacy/create-templated-element-type.ts
7371	var __defProp$3 = Object.defineProperty;
7372	var __defNormalProp$3 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp$3(obj, key, {
7373	enumerable: true,
7374	configurable: true,
7375	writable: true,
7376	value
7377	}) : obj[key] = value, "__defNormalProp");
7378	var __publicField$3 = /* @__PURE__ */ __name((obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value), "__publicField");
7379	function canBeTemplated(element) {
7380	return !!(element.atomic_props_schema && element.twig_templates && element.twig_main_template && element.base_styles_dictionary);
7381	}
7382	function createTemplatedElementView({ type, renderer, element }) {
7383	const BaseView = createElementViewClassDeclaration();
7384	const { templateKey, baseStylesDictionary, resolveProps, defaultHtmlTag, htmlTagFollowsLink } = setupTwigRenderer({
7385	type,
7386	renderer,
7387	element
7388	});
7389	return class extends BaseView {
7390	constructor() {
7391	super(...arguments);
7392	__publicField$3(this, "_abortController", null);
7393	__publicField$3(this, "_lastResolvedSettingsHash", null);
7394	__publicField$3(this, "_domUpdateWasSkipped", false);
7395	}
7396	getTemplateType() {
7397	return "twig";
7398	}
7399	getNamespaceKey() {
7400	return type;
7401	}
7402	renderOnChange() {
7403	this.render();
7404	}
7405	getRenderContext() {
7406	return this._parent?.getRenderContext?.();
7407	}
7408	getResolverRenderContext() {
7409	return this._parent?.getResolverRenderContext?.();
7410	}
7411	invalidateRenderCache() {
7412	this._lastResolvedSettingsHash = null;
7413	}
7414	render() {
7415	this._abortController?.abort();
7416	this._abortController = new AbortController();
7417	const process = signalizedProcess(this._abortController.signal).then(() => this._beforeRender()).then(() => this._renderTemplate()).then(() => this._renderChildren()).then(() => this._afterRender());
7418	this._currentRenderPromise = process.execute();
7419	return this._currentRenderPromise;
7420	}
7421	async _renderChildren() {
7422	if (this._shouldReuseChildren()) rerenderExistingChildren(this);
7423	else super._renderChildren();
7424	await waitForChildrenToComplete(this);
7425	}
7426	_shouldReuseChildren() {
7427	return this._domUpdateWasSkipped && this.children?.length > 0;
7428	}
7429	async _renderTemplate() {
7430	this.triggerMethod("before:render:template");
7431	await signalizedProcess(this._abortController?.signal).then((_, signal) => {
7432	const settings = this.model.get("settings").toJSON();
7433	return resolveProps({
7434	props: settings,
7435	signal,
7436	renderContext: this.getResolverRenderContext()
7437	});
7438	}).then((settings) => {
7439	return this.afterSettingsResolve(settings);
7440	}).then(async (settings) => {
7441	const settingsHash = JSON.stringify(settings);
7442	if (!(settingsHash !== this._lastResolvedSettingsHash) && this.isRendered) {
7443	this._domUpdateWasSkipped = true;
7444	return null;
7445	}
7446	this._domUpdateWasSkipped = false;
7447	this._lastResolvedSettingsHash = settingsHash;
7448	const context = {
7449	id: this.model.get("id"),
7450	interaction_id: this.getInteractionId(),
7451	type,
7452	settings,
7453	tag: computeHtmlTag(settings, defaultHtmlTag, { followLink: htmlTagFollowsLink }),
7454	base_styles: baseStylesDictionary,
7455	...this.getResolverRenderContext?.() ?? {}
7456	};
7457	return renderer.render(templateKey, context);
7458	}).then((html) => {
7459	if (html === null) return;
7460	this.$el.html(html);
7461	}).execute();
7462	this.bindUIElements();
7463	this.triggerMethod("render:template");
7464	}
7465	afterSettingsResolve(settings) {
7466	return settings;
7467	}
7468	_beforeRender() {
7469	createBeforeRender(this);
7470	}
7471	_afterRender() {
7472	createAfterRender(this);
7473	}
7474	_doAfterRender(callback) {
7475	if (this.isRendered) callback();
7476	else this.once("render", callback);
7477	}
7478	_openEditingPanel(options) {
7479	this._doAfterRender(() => super._openEditingPanel(options));
7480	}
7481	getInteractionId() {
7482	const originId = this.model.get("originId");
7483	const id = this.model.get("id");
7484	return originId ?? id;
7485	}
7486	};
7487	}
7488
7489	//#endregion
7490	//#region packages/packages/core/editor-canvas/src/legacy/create-nested-templated-element-type.ts
7491	var STYLES_REFERENCE_UNTRACKED = /* @__PURE__ */ Symbol("styles-reference-untracked");
7492	function canBeNestedTemplated(element) {
7493	return canBeTemplated(element) && "support_nesting" in element && !!element.support_nesting;
7494	}
7495	function createNestedTemplatedElementType({ type, renderer, element, modelExtensions }) {
7496	const legacyWindow = window;
7497	return class extends legacyWindow.elementor.modules.elements.types.Base {
7498	getType() {
7499	return type;
7500	}
7501	getView() {
7502	return createNestedTemplatedElementView({
7503	type,
7504	renderer,
7505	element
7506	});
7507	}
7508	getModel() {
7509	const BaseModel = legacyWindow.elementor.modules.elements.models.AtomicElementBase;
7510	if (modelExtensions && Object.keys(modelExtensions).length > 0) return BaseModel.extend(modelExtensions);
7511	return BaseModel;
7512	}
7513	};
7514	}
7515	function buildEditorAttributes(model) {
7516	const id = model.get("id");
7517	const originId = model.get("originId");
7518	const attrs = {
7519	"data-model-cid": model.cid ?? "",
7520	"data-interaction-id": originId ?? id,
7521	"x-ignore": "true"
7522	};
7523	return Object.entries(attrs).map(([key, value]) => `${key}="${value}"`).join(" ");
7524	}
7525	function buildEditorClasses(model) {
7526	return [
7527	"elementor-element",
7528	"elementor-element-edit-mode",
7529	`elementor-element-${model.get("id")}`
7530	].join(" ");
7531	}
7532	function createNestedTemplatedElementView({ type, renderer, element }) {
7533	const legacyWindow = window;
7534	const { templateKey, baseStylesDictionary, resolveProps, defaultHtmlTag, htmlTagFollowsLink } = setupTwigRenderer({
7535	type,
7536	renderer,
7537	element
7538	});
7539	const AtomicElementBaseView = legacyWindow.elementor.modules.elements.views.createAtomicElementBase(type);
7540	const parentRenderChildren = AtomicElementBaseView.prototype._renderChildren;
7541	const parentOpenEditingPanel = AtomicElementBaseView.prototype._openEditingPanel;
7542	const parentAddElement = AtomicElementBaseView.prototype.addElement;
7543	return AtomicElementBaseView.extend({
7544	_abortController: null,
7545	_lastResolvedSettingsHash: null,
7546	_lastRenderedStyles: STYLES_REFERENCE_UNTRACKED,
7547	_domUpdateWasSkipped: false,
7548	template: false,
7549	attributes() {
7550	return { "data-model-cid": this.model.cid };
7551	},
7552	getTemplateType() {
7553	return "twig";
7554	},
7555	invalidateRenderCache() {
7556	this._lastResolvedSettingsHash = null;
7557	},
7558	renderOnChange() {
7559	this.render();
7560	},
7561	render() {
7562	this._abortController?.abort();
7563	this._abortController = new AbortController();
7564	const process = signalizedProcess(this._abortController.signal).then(() => this._beforeRender()).then(() => this._renderTemplate()).then(() => this._onTemplateReady()).then(() => this._renderChildren()).then(() => this._afterRender());
7565	this._currentRenderPromise = process.execute();
7566	return this._currentRenderPromise;
7567	},
7568	_beforeRender() {
7569	createBeforeRender(this);
7570	},
7571	_onTemplateReady() {
7572	this.dispatchPreviewEvent("elementor/element/render");
7573	},
7574	_afterRender() {
7575	createAfterRender(this);
7576	this.dispatchPreviewEvent("elementor/element/rendered");
7577	requestAnimationFrame(() => {
7578	this._initAlpine();
7579	});
7580	this.model.trigger("render:complete");
7581	this._notifyStylesChanged();
7582	},
7583	_notifyStylesChanged() {
7584	const styles = this.model.get("styles");
7585	if (this._lastRenderedStyles !== STYLES_REFERENCE_UNTRACKED && styles === this._lastRenderedStyles) return;
7586	this._lastRenderedStyles = styles;
7587	window.dispatchEvent(new CustomEvent(_elementor_editor_elements.ELEMENT_STYLE_CHANGE_EVENT));
7588	},
7589	async _renderTemplate() {
7590	const model = this.model;
7591	this.triggerMethod("before:render:template");
7592	await signalizedProcess(this._abortController?.signal).then((_, signal) => {
7593	const settings = model.get("settings").toJSON();
7594	return resolveProps({
7595	props: settings,
7596	signal,
7597	renderContext: this.getResolverRenderContext?.()
7598	});
7599	}).then(async (settings) => {
7600	const resolvedSettings = this.afterSettingsResolve(settings);
7601	const settingsHash = JSON.stringify(resolvedSettings);
7602	if (!(settingsHash !== this._lastResolvedSettingsHash) && this.isRendered) {
7603	this._domUpdateWasSkipped = true;
7604	return null;
7605	}
7606	this._domUpdateWasSkipped = false;
7607	this._lastResolvedSettingsHash = settingsHash;
7608	const context = {
7609	id: model.get("id"),
7610	interaction_id: this.getInteractionId(),
7611	type,
7612	settings: resolvedSettings,
7613	tag: computeHtmlTag(resolvedSettings, defaultHtmlTag, { followLink: htmlTagFollowsLink }),
7614	base_styles: baseStylesDictionary,
7615	editor_attributes: buildEditorAttributes(model),
7616	editor_classes: buildEditorClasses(model),
7617	...this.getResolverRenderContext?.() ?? {}
7618	};
7619	return renderer.render(templateKey, context);
7620	}).then((html) => {
7621	if (html === null) return;
7622	this._attachTwigContent(html);
7623	}).execute();
7624	this.bindUIElements();
7625	this.triggerMethod("render:template");
7626	},
7627	afterSettingsResolve(settings) {
7628	return settings;
7629	},
7630	getRenderContext() {
7631	return this._parent?.getRenderContext?.();
7632	},
7633	getResolverRenderContext() {
7634	return this._parent?.getResolverRenderContext?.();
7635	},
7636	getChildType() {
7637	const allowedTypes = element.allowed_child_types ?? [];
7638	if (allowedTypes && allowedTypes.length > 0) return allowedTypes;
7639	return AtomicElementBaseView.prototype.getChildType.call(this);
7640	},
7641	_attachTwigContent(html) {
7642	const $newContent = legacyWindow.jQuery(html);
7643	const oldEl = this.$el.get(0);
7644	const newEl = $newContent.get(0);
7645	if (!oldEl \|\| !newEl) return;
7646	this._destroyAlpine();
7647	const overlayHTML = this.getHandlesOverlay()?.get(0)?.outerHTML ?? "";
7648	const needsTagSwap = oldEl.tagName !== newEl.tagName;
7649	const targetEl = needsTagSwap ? (oldEl.ownerDocument ?? document).createElement(newEl.tagName) : oldEl;
7650	Array.from(newEl.attributes).forEach((attr) => {
7651	targetEl.setAttribute(attr.name, attr.value);
7652	});
7653	targetEl.innerHTML = overlayHTML + newEl.innerHTML;
7654	if (needsTagSwap) {
7655	oldEl.replaceWith(targetEl);
7656	this.setElement(legacyWindow.jQuery(targetEl));
7657	}
7658	},
7659	async _renderChildren() {
7660	if (this._shouldReuseChildren()) rerenderExistingChildren(this);
7661	else parentRenderChildren.call(this);
7662	await waitForChildrenToComplete(this);
7663	this._removeChildrenPlaceholder();
7664	},
7665	_shouldReuseChildren() {
7666	return this._domUpdateWasSkipped && this.children?.length > 0;
7667	},
7668	_removeChildrenPlaceholder() {
7669	const el = this.$el.get(0);
7670	if (!el) return;
7671	Array.from(el.childNodes).find((node) => node.nodeType === Node.COMMENT_NODE && node.nodeValue?.trim() === "elementor-children-placeholder")?.remove();
7672	},
7673	getChildViewContainer() {
7674	this.childViewContainer = "";
7675	return this.$el;
7676	},
7677	attachBuffer(_collectionView, buffer) {
7678	const el = this.$el.get(0);
7679	if (!el) return;
7680	const placeholderComment = Array.from(el.childNodes).find((node) => node.nodeType === Node.COMMENT_NODE && node.nodeValue?.trim() === "elementor-children-placeholder");
7681	if (placeholderComment) {
7682	placeholderComment.parentNode?.insertBefore(buffer, placeholderComment);
7683	placeholderComment.remove();
7684	} else el.append(buffer);
7685	},
7686	getDomElement() {
7687	return this.$el;
7688	},
7689	onBeforeDestroy() {
7690	this._abortController?.abort();
7691	},
7692	onDestroy() {
7693	this.dispatchPreviewEvent("elementor/element/destroy");
7694	},
7695	_destroyAlpine() {
7696	const el = this.$el.get(0);
7697	if (!el) return;
7698	if (!el.getAttribute("x-data")) return;
7699	(el.ownerDocument?.defaultView)?.Alpine?.destroyTree(el);
7700	},
7701	_initAlpine() {
7702	const el = this.$el.get(0);
7703	if (!el) return;
7704	el.removeAttribute("x-ignore");
7705	if (!el.getAttribute("x-data")) return;
7706	(el.ownerDocument?.defaultView)?.Alpine?.initTree(el);
7707	},
7708	_doAfterRender(callback) {
7709	if (this.isRendered) callback();
7710	else this.once("render", callback);
7711	},
7712	_openEditingPanel(options) {
7713	this._doAfterRender(() => parentOpenEditingPanel.call(this, options));
7714	},
7715	addElement(data, options) {
7716	if (this.isRendered) return parentAddElement.call(this, data, options);
7717	return createPendingElement(this, data, options);
7718	},
7719	getInteractionId() {
7720	const originId = this.model.get("originId");
7721	const id = this.model.get("id");
7722	return originId ?? id;
7723	}
7724	});
7725	}
7726
7727	//#endregion
7728	//#region packages/packages/core/editor-canvas/src/legacy/create-pro-promotion-nested-type.ts
7729	function createProPromotionNestedType({ type, renderer, element }) {
7730	if (!canBeNestedTemplated(element)) throw new Error(`Element "${type}" is not a valid nested templated element.`);
7731	const BaseType = createNestedTemplatedElementType({
7732	type,
7733	renderer,
7734	element
7735	});
7736	let PromotionView = null;
7737	return class extends BaseType {
7738	getView() {
7739	if (!PromotionView) PromotionView = createPromotionView(new BaseType().getView());
7740	return PromotionView;
7741	}
7742	};
7743	}
7744	function createPromotionView(BaseView) {
7745	return class extends BaseView {
7746	_afterRender() {
7747	super._afterRender();
7748	const removeBtnSelector = ".e-pro-promotion-placeholder__remove-btn";
7749	const unlockBtnSelector = ".e-pro-promotion-placeholder__unlock-btn";
7750	this.$el.off("click", removeBtnSelector);
7751	this.$el.on("click", removeBtnSelector, (e) => {
7752	e.preventDefault();
7753	e.stopPropagation();
7754	window.$e.run("document/elements/delete", { container: this.container });
7755	});
7756	this.$el.off("click", unlockBtnSelector);
7757	this.$el.on("click", unlockBtnSelector, (e) => {
7758	e.stopPropagation();
7759	});
7760	}
7761	async _renderChildren() {}
7762	behaviors() {
7763	const disabledBehaviors = [
7764	"InlineEditing",
7765	"Draggable",
7766	"Resizable"
7767	];
7768	const behaviorsAsEntries = Object.entries(super.behaviors()).filter(([key]) => !disabledBehaviors.includes(key));
7769	return Object.fromEntries(behaviorsAsEntries);
7770	}
7771	getContextMenuGroups() {
7772	return super.getContextMenuGroups().filter((group) => group.name !== "save");
7773	}
7774	onDestroy(...args) {
7775	super.onDestroy(...args);
7776	this.$el.off("click", ".e-pro-promotion-placeholder__remove-btn");
7777	this.$el.off("click", ".e-pro-promotion-placeholder__unlock-btn");
7778	}
7779	};
7780	}
7781
7782	//#endregion
7783	//#region node_modules/react-dom/client.js
7784	var require_client = /* @__PURE__ */ __commonJSMin(((exports) => {
7785	var m = (globalThis.ReactDOM);
7786	var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
7787	exports.createRoot = function(c, o) {
7788	i.usingClientEntryPoint = true;
7789	try {
7790	return m.createRoot(c, o);
7791	} finally {
7792	i.usingClientEntryPoint = false;
7793	}
7794	};
7795	}));
7796
7797	//#endregion
7798	//#region packages/packages/core/editor-canvas/src/legacy/replacements/base.ts
7799	var import_client = require_client();
7800	var __defProp$2 = Object.defineProperty;
7801	var __defNormalProp$2 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp$2(obj, key, {
7802	enumerable: true,
7803	configurable: true,
7804	writable: true,
7805	value
7806	}) : obj[key] = value, "__defNormalProp");
7807	var __publicField$2 = /* @__PURE__ */ __name((obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value), "__publicField");
7808	var TRIGGER_TIMING = {
7809	before: "before",
7810	after: "after",
7811	never: "never"
7812	};
7813	var ReplacementBase = class {
7814	constructor(settings) {
7815	__publicField$2(this, "getSetting");
7816	__publicField$2(this, "setSetting");
7817	__publicField$2(this, "element");
7818	__publicField$2(this, "type");
7819	__publicField$2(this, "id");
7820	__publicField$2(this, "refreshView");
7821	__publicField$2(this, "reactRoot");
7822	__publicField$2(this, "reactContainer");
7823	this.getSetting = settings.getSetting;
7824	this.setSetting = settings.setSetting;
7825	this.element = settings.element;
7826	this.type = settings.type;
7827	this.id = settings.id;
7828	this.refreshView = settings.refreshView;
7829	this.reactRoot = settings.reactRoot;
7830	this.reactContainer = settings.reactContainer;
7831	}
7832	static getTypes() {
7833	return null;
7834	}
7835	shouldRenderReplacement() {
7836	return true;
7837	}
7838	originalMethodsToTrigger() {
7839	return {
7840	_beforeRender: TRIGGER_TIMING.before,
7841	_afterRender: TRIGGER_TIMING.after,
7842	renderOnChange: TRIGGER_TIMING.never,
7843	onDestroy: TRIGGER_TIMING.never,
7844	render: TRIGGER_TIMING.never
7845	};
7846	}
7847	};
7848
7849	//#endregion
7850	//#region packages/packages/core/editor-canvas/src/legacy/replacements/inline-editing/inline-editing-utils.ts
7851	var EDITOR_ELEMENTS_OUT_OF_IFRAME = [
7852	"#elementor-editor-wrapper-v2",
7853	"#elementor-navigator",
7854	"#elementor-panel"
7855	];
7856	var TOOLBAR_ANCHOR_ID_PREFIX = "inline-editing-toolbar-anchor";
7857	var TOOLBAR_ANCHOR_STATIC_STYLES = {
7858	backgroundColor: "transparent",
7859	border: "none",
7860	outline: "none",
7861	boxShadow: "none",
7862	padding: "0",
7863	margin: "0",
7864	borderRadius: "0",
7865	overflow: "hidden",
7866	opacity: "0",
7867	pointerEvents: "none",
7868	position: "absolute",
7869	display: "block"
7870	};
7871	var INLINE_EDITING_PROPERTY_PER_TYPE = {
7872	"e-button": "text",
7873	"e-form-label": "text",
7874	"e-heading": "title",
7875	"e-paragraph": "paragraph",
7876	"e-form-submit-button": "text"
7877	};
7878	var getInlineEditorElement = (elementWrapper, expectedTag) => {
7879	return !expectedTag ? null : elementWrapper.querySelector(expectedTag);
7880	};
7881	var useOnClickOutsideIframe = (handleUnmount) => {
7882	const asyncUnmountInlineEditor = (0, react.useCallback)(() => queueMicrotask(handleUnmount), [handleUnmount]);
7883	(0, react.useEffect)(() => {
7884	EDITOR_ELEMENTS_OUT_OF_IFRAME.forEach((selector) => document?.querySelector(selector)?.addEventListener("mousedown", asyncUnmountInlineEditor));
7885	return () => EDITOR_ELEMENTS_OUT_OF_IFRAME.forEach((selector) => document?.querySelector(selector)?.removeEventListener("mousedown", asyncUnmountInlineEditor));
7886	}, []);
7887	};
7888	var useRenderToolbar = (ownerDocument, id) => {
7889	const [anchor, setAnchor] = (0, react.useState)(null);
7890	(0, react.useEffect)(() => {
7891	if (!anchor) removeToolbarAnchor(ownerDocument, id);
7892	}, [
7893	anchor,
7894	ownerDocument,
7895	id
7896	]);
7897	const onSelectionEnd = (view) => {
7898	const hasSelection = !view.state.selection.empty;
7899	removeToolbarAnchor(ownerDocument, id);
7900	if (hasSelection) setAnchor(createAnchorBasedOnSelection(ownerDocument, id));
7901	else setAnchor(null);
7902	};
7903	return {
7904	onSelectionEnd,
7905	anchor,
7906	clearAnchor: (0, react.useCallback)(() => {
7907	setAnchor(null);
7908	}, [])
7909	};
7910	};
7911	var createAnchorBasedOnSelection = (ownerDocument, id) => {
7912	const selection = ownerDocument.defaultView?.getSelection();
7913	if (!selection) return null;
7914	const selectionRect = selection.getRangeAt(0).getBoundingClientRect();
7915	const bodyRect = ownerDocument.body.getBoundingClientRect();
7916	const toolbarAnchor = ownerDocument.createElement("span");
7917	styleToolbarAnchor(toolbarAnchor, selectionRect, bodyRect);
7918	toolbarAnchor.setAttribute("id", getToolbarAnchorId(id));
7919	ownerDocument.body.appendChild(toolbarAnchor);
7920	return toolbarAnchor;
7921	};
7922	var removeToolbarAnchor = (ownerDocument, id) => {
7923	const toolbarAnchor = getToolbarAnchor(ownerDocument, id);
7924	if (toolbarAnchor) ownerDocument.body.removeChild(toolbarAnchor);
7925	};
7926	var getToolbarAnchorId = (id) => `${TOOLBAR_ANCHOR_ID_PREFIX}-${id}`;
7927	var getToolbarAnchor = (ownerDocument, id) => ownerDocument.getElementById(getToolbarAnchorId(id));
7928	var styleToolbarAnchor = (anchor, selectionRect, bodyRect) => {
7929	const { width, height } = selectionRect;
7930	Object.assign(anchor.style, {
7931	...TOOLBAR_ANCHOR_STATIC_STYLES,
7932	top: `${selectionRect.top - bodyRect.top}px`,
7933	left: `${selectionRect.left - bodyRect.left}px`,
7934	width: `${width}px`,
7935	height: `${height}px`
7936	});
7937	};
7938	var horizontalShifterMiddleware = {
7939	name: "horizontalShifter",
7940	fn(state) {
7941	const { x: left, y: top, elements: { reference: anchor, floating } } = state;
7942	const newState = {
7943	...state,
7944	x: left,
7945	y: top
7946	};
7947	if (left < 0) {
7948	newState.x = 0;
7949	return newState;
7950	}
7951	const anchorRect = anchor.getBoundingClientRect();
7952	const right = left + floating.offsetWidth;
7953	const documentWidth = anchor.ownerDocument.body.offsetWidth;
7954	if (right > documentWidth && anchorRect.right < right) {
7955	newState.x = left - (right - documentWidth);
7956	return newState;
7957	}
7958	return newState;
7959	}
7960	};
7961
7962	//#endregion
7963	//#region packages/packages/core/editor-canvas/src/legacy/replacements/inline-editing/canvas-inline-editor.tsx
7964	var CanvasInlineEditor = ({ elementClasses, initialValue, expectedTag, rootElement, contentElement, id, setValue, requestDestroy }) => {
7965	const [active, setActive] = (0, react.useState)(true);
7966	const [editor, setEditor] = (0, react.useState)(null);
7967	const { onSelectionEnd, anchor: toolbarAnchor, clearAnchor } = useRenderToolbar(rootElement.ownerDocument, id);
7968	(0, react.useEffect)(() => {
7969	if (!active) {
7970	clearAnchor();
7971	requestDestroy();
7972	}
7973	}, [
7974	active,
7975	clearAnchor,
7976	requestDestroy
7977	]);
7978	const dismiss = (0, react.useCallback)(() => {
7979	setEditor(null);
7980	setActive(false);
7981	}, []);
7982	useOnClickOutsideIframe(dismiss);
7983	(0, react.useEffect)(() => {
7984	const ownerDocument = contentElement.ownerDocument;
7985	const handleClickAway = (event) => {
7986	if (contentElement.contains(event.target)) return;
7987	dismiss();
7988	};
7989	ownerDocument.addEventListener("mousedown", handleClickAway);
7990	return () => ownerDocument.removeEventListener("mousedown", handleClickAway);
7991	}, [contentElement, dismiss]);
7992	if (!active) return null;
7993	return /* @__PURE__ / react.createElement(_elementor_ui.ThemeProvider, null, / @__PURE__ */ react.createElement(InlineEditingOverlay, {
7994	expectedTag,
7995	rootElement,
7996	id
7997	}), /* @__PURE__ */ react.createElement(_elementor_editor_controls.InlineEditor, {
7998	onEditorCreate: setEditor,
7999	mountElement: contentElement,
8000	editorProps: { attributes: { style: "outline: none; display: inherit; justify-content: inherit; align-items: inherit; flex-direction: inherit; text-align: inherit;" } },
8001	elementClasses,
8002	value: initialValue,
8003	setValue,
8004	onBlur: dismiss,
8005	autofocus: true,
8006	onSelectionEnd
8007	}), toolbarAnchor && editor && /* @__PURE__ */ react.createElement(InlineEditingToolbar, {
8008	anchor: toolbarAnchor,
8009	editor,
8010	id
8011	}));
8012	};
8013	var InlineEditingOverlay = ({ expectedTag, rootElement, id }) => {
8014	const [overlayRefElement, setOverlayElement] = (0, react.useState)(getInlineEditorElement(rootElement, expectedTag));
8015	(0, react.useEffect)(() => {
8016	setOverlayElement(getInlineEditorElement(rootElement, expectedTag));
8017	}, [expectedTag, rootElement]);
8018	return overlayRefElement ? /* @__PURE__ */ react.createElement(OutlineOverlay, {
8019	element: overlayRefElement,
8020	id,
8021	isSelected: true
8022	}) : null;
8023	};
8024	var InlineEditingToolbar = ({ anchor, editor, id }) => {
8025	const { refs, floatingStyles } = useFloating({
8026	placement: "top",
8027	strategy: "fixed",
8028	transform: false,
8029	whileElementsMounted: autoUpdate,
8030	middleware: [horizontalShifterMiddleware, flip()]
8031	});
8032	(0, react.useLayoutEffect)(() => {
8033	refs.setReference(anchor);
8034	return () => refs.setReference(null);
8035	}, [anchor, refs]);
8036	return /* @__PURE__ / react.createElement(FloatingPortal, { id: CANVAS_WRAPPER_ID }, / @__PURE__ */ react.createElement(_elementor_ui.Box, {
8037	ref: refs.setFloating,
8038	role: "presentation",
8039	style: {
8040	...floatingStyles,
8041	pointerEvents: "none"
8042	}
8043	}, /* @__PURE__ */ react.createElement(_elementor_editor_controls.InlineEditorToolbar, {
8044	editor,
8045	elementId: id
8046	})));
8047	};
8048
8049	//#endregion
8050	//#region packages/packages/core/editor-canvas/src/legacy/replacements/inline-editing/inline-editing-eligibility.ts
8051	var hasKey = (propType) => {
8052	return "key" in propType;
8053	};
8054	var TEXT_PROP_TYPE_KEYS = /* @__PURE__ */ new Set([
8055	_elementor_editor_props.escapedHtmlPropTypeUtil.key,
8056	_elementor_editor_props.htmlV3PropTypeUtil.key,
8057	_elementor_editor_props.stringPropTypeUtil.key
8058	]);
8059	var isCoreTextPropTypeKey = (key) => {
8060	return TEXT_PROP_TYPE_KEYS.has(key);
8061	};
8062	var isAllowedBySchema = (propTypeFromSchema) => {
8063	if (!propTypeFromSchema) return false;
8064	if (hasKey(propTypeFromSchema) && isCoreTextPropTypeKey(propTypeFromSchema.key)) return true;
8065	if (propTypeFromSchema.kind !== "union") return false;
8066	return [...TEXT_PROP_TYPE_KEYS].some((key) => propTypeFromSchema.prop_types[key]);
8067	};
8068	var isInlineEditingAllowed = ({ rawValue, propTypeFromSchema }) => {
8069	if (rawValue === null \|\| rawValue === void 0) return isAllowedBySchema(propTypeFromSchema);
8070	return _elementor_editor_props.escapedHtmlPropTypeUtil.isValid(rawValue) \|\| _elementor_editor_props.htmlV3PropTypeUtil.isValid(rawValue) \|\| _elementor_editor_props.stringPropTypeUtil.isValid(rawValue);
8071	};
8072
8073	//#endregion
8074	//#region packages/packages/core/editor-canvas/src/legacy/replacements/inline-editing/inline-editing-elements.tsx
8075	var __defProp$1 = Object.defineProperty;
8076	var __defNormalProp$1 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp$1(obj, key, {
8077	enumerable: true,
8078	configurable: true,
8079	writable: true,
8080	value
8081	}) : obj[key] = value, "__defNormalProp");
8082	var __publicField$1 = /* @__PURE__ */ __name((obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value), "__publicField");
8083	var HISTORY_DEBOUNCE_WAIT = 800;
8084	var InlineEditingReplacement = class extends ReplacementBase {
8085	constructor() {
8086	super(...arguments);
8087	__publicField$1(this, "handlerAttached", false);
8088	__publicField$1(this, "editing", false);
8089	__publicField$1(this, "handleRenderInlineEditor", () => {
8090	if (this.isEditingModeActive() \|\| !this.isInlineEditingEligible()) return;
8091	this.renderInlineEditor();
8092	});
8093	}
8094	getReplacementKey() {
8095	return "inline-editing";
8096	}
8097	static getTypes() {
8098	return Object.keys(INLINE_EDITING_PROPERTY_PER_TYPE);
8099	}
8100	isEditingModeActive() {
8101	return this.editing;
8102	}
8103	shouldRenderReplacement() {
8104	return this.isInlineEditingEligible() && (0, _elementor_editor_v1_adapters.getCurrentEditMode)() === "edit";
8105	}
8106	renderOnChange() {
8107	if (this.isEditingModeActive()) return;
8108	this.refreshView();
8109	}
8110	onDestroy() {
8111	this.resetInlineEditorRoot();
8112	}
8113	_beforeRender() {
8114	this.resetInlineEditorRoot();
8115	}
8116	_afterRender() {
8117	if (this.isInlineEditingEligible() && !this.handlerAttached) {
8118	this.element.addEventListener("click", this.handleRenderInlineEditor);
8119	this.handlerAttached = true;
8120	}
8121	}
8122	originalMethodsToTrigger() {
8123	const before = this.isEditingModeActive() ? TRIGGER_TIMING.never : TRIGGER_TIMING.before;
8124	const after = this.isEditingModeActive() ? TRIGGER_TIMING.never : TRIGGER_TIMING.after;
8125	return {
8126	_beforeRender: before,
8127	_afterRender: after,
8128	renderOnChange: after,
8129	onDestroy: TRIGGER_TIMING.after,
8130	render: before
8131	};
8132	}
8133	resetInlineEditorRoot() {
8134	this.element.removeEventListener("click", this.handleRenderInlineEditor);
8135	this.handlerAttached = false;
8136	this.reactRoot.render(null);
8137	this.editing = false;
8138	}
8139	unmountInlineEditor() {
8140	this.resetInlineEditorRoot();
8141	this.refreshView();
8142	}
8143	isInlineEditingEligible() {
8144	const settingKey = this.getInlineEditablePropertyName();
8145	return isInlineEditingAllowed({
8146	rawValue: this.getSetting(settingKey),
8147	propTypeFromSchema: this.getInlineEditablePropType()
8148	});
8149	}
8150	getInlineEditablePropertyName() {
8151	return INLINE_EDITING_PROPERTY_PER_TYPE[this.type] ?? "";
8152	}
8153	getInlineEditablePropType() {
8154	const propSchema = (0, _elementor_editor_elements.getElementType)(this.type)?.propsSchema;
8155	const propertyName = this.getInlineEditablePropertyName();
8156	return propSchema?.[propertyName] ?? null;
8157	}
8158	getInlineEditablePropValue() {
8159	const prop = this.getInlineEditablePropType();
8160	const settingKey = this.getInlineEditablePropertyName();
8161	return this.getSetting(settingKey) ?? prop?.default ?? null;
8162	}
8163	getExtractedContentValue() {
8164	const propValue = this.getInlineEditablePropValue();
8165	if (_elementor_editor_props.escapedHtmlPropTypeUtil.isValid(propValue)) return _elementor_editor_props.escapedHtmlPropTypeUtil.extract(propValue) ?? "";
8166	const extracted = _elementor_editor_props.htmlV3PropTypeUtil.extract(propValue);
8167	return _elementor_editor_props.stringPropTypeUtil.extract(extracted?.content ?? null) ?? "";
8168	}
8169	createContentPropValue(value) {
8170	const content = value \|\| "";
8171	if (this.getInlineEditablePropTypeKey() === _elementor_editor_props.htmlV3PropTypeUtil.key) return _elementor_editor_props.htmlV3PropTypeUtil.create({
8172	content: _elementor_editor_props.stringPropTypeUtil.create(content),
8173	children: []
8174	});
8175	return _elementor_editor_props.escapedHtmlPropTypeUtil.create(content);
8176	}
8177	setContentValue(value) {
8178	const settingKey = this.getInlineEditablePropertyName();
8179	const valueToSave = this.createContentPropValue(value);
8180	(0, _elementor_editor_v1_adapters.undoable)({
8181	do: () => {
8182	const prevValue = this.getInlineEditablePropValue();
8183	this.runCommand(settingKey, valueToSave);
8184	return prevValue;
8185	},
8186	undo: (_, prevValue) => {
8187	this.runCommand(settingKey, prevValue ?? null);
8188	}
8189	}, {
8190	title: (0, _elementor_editor_elements.getElementLabel)(this.id),
8191	subtitle: (0, _wordpress_i18n.__)("%s edited", "elementor").replace("%s", this.getInlineEditablePropTypeKey() ?? "Inline editing"),
8192	debounce: { wait: HISTORY_DEBOUNCE_WAIT }
8193	})();
8194	}
8195	getInlineEditablePropTypeKey() {
8196	const propType = this.getInlineEditablePropType();
8197	if (!propType) return null;
8198	if (propType.kind === "union") {
8199	const textKeys = [
8200	_elementor_editor_props.escapedHtmlPropTypeUtil.key,
8201	_elementor_editor_props.htmlV3PropTypeUtil.key,
8202	_elementor_editor_props.stringPropTypeUtil.key
8203	];
8204	for (const key of textKeys) if (propType.prop_types[key]) return key;
8205	return null;
8206	}
8207	if ("key" in propType && typeof propType.key === "string") return propType.key;
8208	return null;
8209	}
8210	runCommand(key, value) {
8211	(0, _elementor_editor_v1_adapters.__privateRunCommandSync)("document/elements/set-settings", {
8212	container: (0, _elementor_editor_elements.getContainer)(this.id),
8213	settings: { [key]: value }
8214	}, { internal: true });
8215	(0, _elementor_editor_v1_adapters.__privateRunCommandSync)("document/save/set-is-modified", { status: true }, { internal: true });
8216	}
8217	getExpectedTag() {
8218	const tagPropType = this.getTagPropType();
8219	return _elementor_editor_props.stringPropTypeUtil.extract(this.getSetting("tag") ?? null) ?? _elementor_editor_props.stringPropTypeUtil.extract(tagPropType?.default ?? null) ?? null;
8220	}
8221	getTagPropType() {
8222	const propsSchema = (0, _elementor_editor_elements.getElementType)(this.type)?.propsSchema;
8223	if (!propsSchema?.tag) return null;
8224	const tagPropType = propsSchema.tag ?? null;
8225	if (tagPropType.kind === "union") return tagPropType.prop_types.string ?? null;
8226	return tagPropType;
8227	}
8228	renderInlineEditor() {
8229	if (this.isEditingModeActive()) this.resetInlineEditorRoot();
8230	const contentElement = this.element.children?.[0];
8231	if (!contentElement) return;
8232	const elementClasses = contentElement.classList.toString();
8233	const propValue = this.getExtractedContentValue();
8234	const expectedTag = this.getExpectedTag();
8235	contentElement.innerHTML = "";
8236	this.editing = true;
8237	this.reactRoot.render(/* @__PURE__ */ react.createElement(CanvasInlineEditor, {
8238	elementClasses,
8239	initialValue: propValue,
8240	expectedTag,
8241	rootElement: this.element,
8242	contentElement,
8243	id: this.id,
8244	setValue: this.setContentValue.bind(this),
8245	requestDestroy: this.unmountInlineEditor.bind(this)
8246	}));
8247	}
8248	};
8249
8250	//#endregion
8251	//#region packages/packages/core/editor-canvas/src/legacy/replacements/manager.ts
8252	var __typeError = (msg) => {
8253	throw TypeError(msg);
8254	};
8255	var __accessCheck = (obj, member, msg) => member.has(obj) \|\| __typeError("Cannot " + msg);
8256	var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
8257	var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
8258	var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
8259	var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
8260	var replacements = /* @__PURE__ */ new Map();
8261	var initViewReplacements = () => {
8262	registerReplacement(InlineEditingReplacement);
8263	};
8264	var registerReplacement = (replacement) => {
8265	const types = replacement.getTypes();
8266	if (!types) return;
8267	types.forEach((type) => {
8268	replacements.set(type, replacement);
8269	});
8270	};
8271	var getReplacement = (type) => {
8272	return replacements.get(type) ?? null;
8273	};
8274	var createViewWithReplacements = (options) => {
8275	var _replacement;
8276	var _config;
8277	var _reactContainer;
8278	var _reactRoot;
8279	var _instances;
8280	var triggerAltMethod_fn;
8281	var _a;
8282	const TemplatedView = createTemplatedElementView(options);
8283	return _a = class extends TemplatedView {
8284	constructor(...args) {
8285	super(...args);
8286	__privateAdd(this, _instances);
8287	__privateAdd(this, _replacement, null);
8288	__privateAdd(this, _config);
8289	__privateAdd(this, _reactContainer);
8290	__privateAdd(this, _reactRoot);
8291	const settings = this.model.get("settings");
8292	__privateSet(this, _reactContainer, this.el.ownerDocument.createElement("div"));
8293	__privateGet(this, _reactContainer).style.display = "none";
8294	this.el.ownerDocument.body.appendChild(__privateGet(this, _reactContainer));
8295	__privateSet(this, _reactRoot, (0, import_client.createRoot)(__privateGet(this, _reactContainer)));
8296	__privateSet(this, _config, {
8297	getSetting: settings.get.bind(settings),
8298	setSetting: settings.set.bind(settings),
8299	element: this.el,
8300	type: this?.model?.get("widgetType") ?? this.container?.model?.get("elType") ?? null,
8301	id: this?.model?.get("id") ?? null,
8302	refreshView: this.refreshView.bind(this),
8303	reactRoot: __privateGet(this, _reactRoot),
8304	reactContainer: __privateGet(this, _reactContainer)
8305	});
8306	}
8307	refreshView() {
8308	this.invalidateRenderCache?.();
8309	this.render();
8310	}
8311	renderOnChange() {
8312	__privateMethod(this, _instances, triggerAltMethod_fn).call(this, "renderOnChange");
8313	}
8314	render() {
8315	const config = __privateGet(this, _config);
8316	const widgetType = config.type;
8317	const ReplacementClass = widgetType ? getReplacement(widgetType) : null;
8318	if (ReplacementClass && !__privateGet(this, _replacement)) __privateSet(this, _replacement, new ReplacementClass(config));
8319	__privateMethod(this, _instances, triggerAltMethod_fn).call(this, "render");
8320	}
8321	onDestroy() {
8322	__privateMethod(this, _instances, triggerAltMethod_fn).call(this, "onDestroy");
8323	__privateGet(this, _reactRoot).unmount();
8324	__privateGet(this, _reactContainer).remove();
8325	}
8326	_afterRender() {
8327	__privateMethod(this, _instances, triggerAltMethod_fn).call(this, "_afterRender");
8328	}
8329	_beforeRender() {
8330	__privateMethod(this, _instances, triggerAltMethod_fn).call(this, "_beforeRender");
8331	}
8332	}, _replacement = /* @__PURE__ / new WeakMap(), _config = / @__PURE__ / new WeakMap(), _reactContainer = / @__PURE__ / new WeakMap(), _reactRoot = / @__PURE__ / new WeakMap(), _instances = / @__PURE__ */ new WeakSet(), triggerAltMethod_fn = function(methodKey) {
8333	const baseMethod = TemplatedView.prototype[methodKey].bind(this);
8334	const shouldReplace = __privateGet(this, _replacement)?.shouldRenderReplacement();
8335	const altMethod = shouldReplace && __privateGet(this, _replacement)?.[methodKey]?.bind(__privateGet(this, _replacement));
8336	if (!altMethod \|\| !shouldReplace) return baseMethod();
8337	const renderTiming = __privateGet(this, _replacement)?.originalMethodsToTrigger()[methodKey] ?? "never";
8338	if (renderTiming === "before") baseMethod();
8339	altMethod();
8340	if (renderTiming === "after") baseMethod();
8341	}, _a;
8342	};
8343	var createTemplatedElementTypeWithReplacements = ({ type, renderer, element }) => {
8344	const legacyWindow = window;
8345	const view = createViewWithReplacements({
8346	type,
8347	renderer,
8348	element
8349	});
8350	return class extends legacyWindow.elementor.modules.elements.types.Widget {
8351	getType() {
8352	return type;
8353	}
8354	getView() {
8355	return view;
8356	}
8357	};
8358	};
8359
8360	//#endregion
8361	//#region packages/packages/core/editor-canvas/src/legacy/init-legacy-views.ts
8362	var elementsLegacyTypes = {};
8363	var modelExtensionsRegistry = {};
8364	function registerModelExtensions(type, extensions) {
8365	modelExtensionsRegistry[type] = extensions;
8366	}
8367	function registerElementType(type, elementTypeGenerator) {
8368	elementsLegacyTypes[type] = elementTypeGenerator;
8369	if ((0, _elementor_editor_v1_adapters.__privateIsReady)()) registerElementInLegacyManager(type, createDomRenderer());
8370	}
8371	function initLegacyViews() {
8372	(0, _elementor_editor_v1_adapters.__privateListenTo)((0, _elementor_editor_v1_adapters.v1ReadyEvent)(), () => {
8373	const widgetsCache = (0, _elementor_editor_elements.getWidgetsCache)() ?? {};
8374	const renderer = createDomRenderer();
8375	registerProPromotionTypes(widgetsCache);
8376	Object.keys(widgetsCache).forEach((type) => {
8377	registerElementInLegacyManager(type, renderer);
8378	});
8379	});
8380	}
8381	function registerElementInLegacyManager(type, renderer) {
8382	const element = ((0, _elementor_editor_elements.getWidgetsCache)() ?? {})[type];
8383	if (!element?.atomic) return;
8384	tryRegisterElement(window, type, element, resolveElementType(type, renderer, element));
8385	}
8386	function registerProPromotionTypes(widgetsCache) {
8387	Object.entries(widgetsCache).forEach(([type, element]) => {
8388	if (element.meta?.is_pro_promotion) registerElementType(type, (options) => createProPromotionNestedType(options));
8389	});
8390	}
8391	function resolveElementType(type, renderer, element) {
8392	if (canBeNestedTemplated(element)) {
8393	const customGenerator2 = elementsLegacyTypes[type];
8394	return customGenerator2 ? customGenerator2({
8395	type,
8396	renderer,
8397	element
8398	}) : createNestedTemplatedType(type, renderer, element);
8399	}
8400	if (!canBeTemplated(element)) return createElementType(type);
8401	const customGenerator = elementsLegacyTypes[type];
8402	return customGenerator ? customGenerator({
8403	type,
8404	renderer,
8405	element
8406	}) : createTemplatedElementTypeWithReplacements({
8407	type,
8408	renderer,
8409	element
8410	});
8411	}
8412	function tryRegisterElement(legacyWindow, type, element, ResolvedElementType) {
8413	if (!(canBeTemplated(element) \|\| canBeNestedTemplated(element))) return;
8414	const elementsManager = legacyWindow.elementor.elementsManager;
8415	const isAlreadyRegistered = Boolean(elementsManager.getElementTypeClass(type));
8416	try {
8417	elementsManager.registerElementType(new ResolvedElementType());
8418	} catch {
8419	if (canBeNestedTemplated(element) && isAlreadyRegistered) elementsManager.elementTypes[type] = new ResolvedElementType();
8420	}
8421	}
8422	function createNestedTemplatedType(type, renderer, element) {
8423	return createNestedTemplatedElementType({
8424	type,
8425	renderer,
8426	element,
8427	modelExtensions: modelExtensionsRegistry[type]
8428	});
8429	}
8430
8431	//#endregion
8432	//#region packages/packages/core/editor-canvas/src/legacy/list-type.ts
8433	var LIST_TYPE = "e-list";
8434	function initListType() {
8435	registerElementType(LIST_TYPE, (options) => createListType(options));
8436	}
8437	function createListType(options) {
8438	const BaseType = createNestedTemplatedElementType(options);
8439	let ListView = null;
8440	return class extends BaseType {
8441	getView() {
8442	if (!ListView) ListView = createListView(options);
8443	return ListView;
8444	}
8445	};
8446	}
8447	function createListView(options) {
8448	return createNestedTemplatedElementView(options).extend({
8449	getRenderContext() {
8450	const parentContext = this._parent?.getRenderContext?.();
8451	const showMarkersProp = this.model.get("settings")?.get?.("show_markers");
8452	const showMarkers = showMarkersProp?.value ?? showMarkersProp ?? true;
8453	return {
8454	...parentContext,
8455	show_markers: showMarkers
8456	};
8457	},
8458	getResolverRenderContext() {
8459	const parentContext = this._parent?.getResolverRenderContext?.();
8460	const showMarkersProp = this.model.get("settings")?.get?.("show_markers");
8461	const showMarkers = showMarkersProp?.value ?? showMarkersProp ?? true;
8462	return {
8463	...parentContext,
8464	show_markers: showMarkers
8465	};
8466	}
8467	});
8468	}
8469
8470	//#endregion
8471	//#region packages/packages/core/editor-canvas/src/legacy/tabs-model-extensions.ts
8472	var tabModelExtensions = { modifyDefaultChildren(elements) {
8473	if (!Array.isArray(elements) \|\| elements.length === 0) return elements;
8474	const [paragraph] = elements;
8475	const position = this.get("editor_settings")?.initial_position;
8476	if (!position \|\| !paragraph \|\| typeof paragraph !== "object") return elements;
8477	const paragraphElement = paragraph;
8478	return [{
8479	...paragraphElement,
8480	settings: {
8481	...paragraphElement.settings,
8482	paragraph: _elementor_editor_props.escapedHtmlPropTypeUtil.create(`Tab ${position}`)
8483	}
8484	}, ...elements.slice(1)];
8485	} };
8486	function initTabsModelExtensions() {
8487	registerModelExtensions("e-tab", tabModelExtensions);
8488	}
8489
8490	//#endregion
8491	//#region packages/packages/core/editor-canvas/src/mcp/resources/available-widgets-resource.ts
8492	var MCP_PROXY_URL$3 = "elementor/v1/mcp-proxy";
8493	var AVAILABLE_WIDGETS_URI = "elementor://context/available-widgets";
8494	var AVAILABLE_WIDGETS_URI_V4 = "elementor://context/available-widgets/v4";
8495	var fetchWidgets = async () => {
8496	const { data } = await (0, _elementor_http_client.httpService)().post(MCP_PROXY_URL$3, {
8497	tool: "list-widget-schemas",
8498	input: { summary: true }
8499	});
8500	return data.data?.widgets ?? [];
8501	};
8502	var buildContents = async (uri) => {
8503	const widgets = await fetchWidgets();
8504	return { contents: [{
8505	uri,
8506	mimeType: "application/json",
8507	text: JSON.stringify(widgets, null, 2)
8508	}] };
8509	};
8510	var initAvailableWidgetsResource = (reg) => {
8511	const { resource } = reg;
8512	resource("available-widgets-v4", AVAILABLE_WIDGETS_URI_V4, { description: "All registered v4 version widgets" }, async () => buildContents(AVAILABLE_WIDGETS_URI_V4));
8513	resource("available-widgets", AVAILABLE_WIDGETS_URI, { description: "All registered v4 widget types with description." }, async () => buildContents(AVAILABLE_WIDGETS_URI));
8514	};
8515
8516	//#endregion
8517	//#region packages/packages/core/editor-canvas/src/mcp/resources/best-practices-resource.ts
8518	var MCP_PROXY_URL$2 = "elementor/v1/mcp-proxy";
8519	var BEST_PRACTICES_URI = "elementor://style/best-practices";
8520	var initBestPracticesResource = (reg) => {
8521	const { resource } = reg;
8522	resource("style-best-practices", BEST_PRACTICES_URI, {
8523	description: "Design quality guidelines for avoiding generic AI output: typography, color strategy, spacing, motion, and visual hierarchy best practices.",
8524	mimeType: "text/markdown"
8525	}, async (uri) => {
8526	const { data } = await (0, _elementor_http_client.httpService)().get(MCP_PROXY_URL$2, { params: { uri: uri.href } });
8527	return { contents: [{
8528	uri: uri.href,
8529	mimeType: "text/markdown",
8530	text: data.data
8531	}] };
8532	});
8533	};
8534
8535	//#endregion
8536	//#region packages/packages/core/editor-canvas/src/mcp/resources/document-structure-resource.ts
8537	var DOCUMENT_STRUCTURE_URI = "elementor://document/structure";
8538	var initDocumentStructureResource = (reg) => {
8539	const { resource, sendResourceUpdated } = reg;
8540	let currentDocumentStructure = null;
8541	const updateDocumentStructure = () => {
8542	const structure = getDocumentStructure();
8543	const newStructure = JSON.stringify(structure, null, 2);
8544	if (newStructure !== currentDocumentStructure) {
8545	currentDocumentStructure = newStructure;
8546	sendResourceUpdated({ uri: DOCUMENT_STRUCTURE_URI });
8547	}
8548	};
8549	(0, _elementor_editor_v1_adapters.__privateListenTo)([
8550	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/create"),
8551	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/delete"),
8552	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/move"),
8553	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/copy"),
8554	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/paste"),
8555	(0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview"),
8556	(0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/switch")
8557	], updateDocumentStructure);
8558	updateDocumentStructure();
8559	resource("document-structure", DOCUMENT_STRUCTURE_URI, { description: "Document structure." }, async () => {
8560	return { contents: [{
8561	uri: DOCUMENT_STRUCTURE_URI,
8562	text: JSON.stringify(getDocumentStructure(), null, 2)
8563	}] };
8564	});
8565	};
8566	function getDocumentStructure() {
8567	const document = window.elementor?.documents?.getCurrent?.();
8568	if (!document) return { error: "No active document found" };
8569	const elements = (document.container?.children \|\| []).map((container) => extractElementData(container));
8570	return {
8571	documentId: document.id,
8572	documentType: document.config.type,
8573	title: document.config.settings?.post_title \|\| "Untitled",
8574	elements: elements.filter((el) => el !== null)
8575	};
8576	}
8577	function resolveElementVersion$1(element) {
8578	if (element.model?.config?.atomic) return "v4";
8579	const widgetType = element.model?.attributes?.widgetType;
8580	if (widgetType && (0, _elementor_editor_elements.getWidgetsCache)()?.[widgetType]?.atomic_props_schema) return "v4";
8581	return "v3";
8582	}
8583	__name(resolveElementVersion$1, "resolveElementVersion");
8584	function extractElementData(element) {
8585	if (!element \|\| !element.model) return null;
8586	const model = element.model.attributes;
8587	const result = {
8588	id: model.id,
8589	elType: model.elType,
8590	widgetType: model.widgetType \|\| void 0,
8591	version: resolveElementVersion$1(element)
8592	};
8593	const title = model.title \|\| element.model?.editor_settings?.title \|\| element.model.getTitle?.();
8594	if (title) result.title = title;
8595	if (element.children && element.children.length > 0) result.children = element.children.map((child) => extractElementData(child)).filter((child) => child !== null);
8596	return result;
8597	}
8598
8599	//#endregion
8600	//#region packages/packages/core/editor-canvas/src/mcp/resources/dynamic-tags-resource.ts
8601	var DYNAMIC_TAGS_URI = "elementor://dynamic-tags";
8602	var MCP_PROXY_URL$1 = "elementor/v1/mcp-proxy";
8603	var fetchDynamicTags = async () => {
8604	const { data } = await (0, _elementor_http_client.httpService)().get(MCP_PROXY_URL$1, { params: { uri: DYNAMIC_TAGS_URI } });
8605	return data.data ?? "[]";
8606	};
8607	var initDynamicTagsResource = (reg) => {
8608	const { resource } = reg;
8609	resource("dynamic-tags", DYNAMIC_TAGS_URI, {
8610	description: `List of available dynamic tags. To bind a property to a dynamic source, set its value to { "$$type": "dynamic", "value": { "name": <tag name>, "settings": { ... } } } using a tag whose name appears in that property's allowed list, and populate "settings" per the tag entry here.`,
8611	mimeType: "application/json"
8612	}, async (uri) => {
8613	return { contents: [{
8614	uri: uri.href,
8615	mimeType: "application/json",
8616	text: await fetchDynamicTags()
8617	}] };
8618	});
8619	};
8620
8621	//#endregion
8622	//#region packages/packages/core/editor-canvas/src/mcp/resources/editor-state-resource.ts
8623	var CURRENTLY_VIEWED_SCREEN = "The user is currently viewing the Elementor editor";
8624	var PAGE_CONTENT_CHARACTER_LIMIT = 500;
8625	var PREVIEW_TEXT_NODE_MIN_LENGTH = 2;
8626	var EDITOR_STATE_URI = "elementor://context/editor-state";
8627	var initEditorStateResource = (reg) => {
8628	const { resource, sendResourceUpdated } = reg;
8629	let lastSerializedState = "";
8630	const buildState = () => ({
8631	currentlyViewedScreen: CURRENTLY_VIEWED_SCREEN,
8632	pageContent: getPageContentFromPreview(),
8633	pageTitle: getPageTitle()
8634	});
8635	const notifyIfChanged = () => {
8636	const serialized = JSON.stringify(buildState());
8637	if (serialized === lastSerializedState) return;
8638	lastSerializedState = serialized;
8639	sendResourceUpdated({ uri: EDITOR_STATE_URI });
8640	};
8641	(0, _elementor_editor_v1_adapters.__privateListenTo)([(0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/switch"), (0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview")], notifyIfChanged);
8642	lastSerializedState = JSON.stringify(buildState());
8643	resource("editor-state", EDITOR_STATE_URI, { description: "Editor page title, preview text snapshot, and viewed screen label." }, async () => {
8644	return { contents: [{
8645	uri: EDITOR_STATE_URI,
8646	text: JSON.stringify(buildState(), null, 2)
8647	}] };
8648	});
8649	};
8650	function getPageContentFromPreview() {
8651	try {
8652	const root = window.elementor?.$previewContents?.[0];
8653	if (!root) return null;
8654	const content = [];
8655	const clone = root.cloneNode(true);
8656	clone.querySelectorAll(".elementor-editor-element-settings, #elementor-add-new-section").forEach((el) => {
8657	el.remove();
8658	});
8659	const walk = (node, insideElementorElement = false) => {
8660	const isInside = node.classList?.contains("elementor-element") \|\| insideElementorElement;
8661	if (node.nodeType === Node.TEXT_NODE && isInside) {
8662	const text2 = node.textContent?.trim().replace(/\s+/g, " ");
8663	if (text2 && text2.length > PREVIEW_TEXT_NODE_MIN_LENGTH) content.push(text2);
8664	} else node.childNodes.forEach((child) => {
8665	walk(child, isInside);
8666	});
8667	};
8668	walk(clone);
8669	const text = content.join(" ");
8670	if (text.length > PAGE_CONTENT_CHARACTER_LIMIT) return text.slice(0, PAGE_CONTENT_CHARACTER_LIMIT) + "...";
8671	return text;
8672	} catch {
8673	return null;
8674	}
8675	}
8676	function getPageTitle() {
8677	try {
8678	const postTitle = (window.elementor?.documents?.getCurrent?.())?.config?.settings?.post_title;
8679	if (postTitle) return postTitle;
8680	let title = document.title \|\| "Page";
8681	title = title.split(/\s[‹»\|–—-]\s/)[0];
8682	return title.trim() \|\| "Page";
8683	} catch {
8684	return "Page";
8685	}
8686	}
8687
8688	//#endregion
8689	//#region packages/packages/core/editor-canvas/src/mcp/resources/general-context-resource.ts
8690	var GENERAL_CONTEXT_URI = "elementor://context/general";
8691	var initGeneralContextResource = (reg) => {
8692	const { resource, sendResourceUpdated } = reg;
8693	let lastSerializedPayload = null;
8694	const getPageTitle = () => {
8695	const title = window.elementor?.documents?.getCurrent?.()?.config?.settings?.post_title;
8696	if (!title?.trim()) return null;
8697	return title;
8698	};
8699	const buildPayload = () => {
8700	const extendedWindow = window;
8701	const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
8702	const postParam = new URLSearchParams(location.search).get("post");
8703	const parsedPostId = postParam ? Number(postParam) : null;
8704	const postId = parsedPostId !== null && Number.isFinite(parsedPostId) ? parsedPostId : null;
8705	const pageTitle = getPageTitle();
8706	const urlObject = new URL(window.location.href);
8707	const pageUrl = urlObject.pathname + urlObject.search;
8708	const pageName = pageTitle \|\| "Elementor Editor";
8709	const plugins = extendedWindow.angieConfig?.plugins;
8710	return {
8711	timezone,
8712	postId,
8713	currentPage: {
8714	pageName,
8715	pageTitle,
8716	pageUrl
8717	},
8718	...plugins && { plugins }
8719	};
8720	};
8721	const pushUpdateIfChanged = () => {
8722	const serialized = JSON.stringify(buildPayload());
8723	if (serialized === lastSerializedPayload) return;
8724	lastSerializedPayload = serialized;
8725	sendResourceUpdated({ uri: GENERAL_CONTEXT_URI });
8726	};
8727	resource("general-context", GENERAL_CONTEXT_URI, { description: "General context: timezone, post id, and current page." }, async () => {
8728	return { contents: [{
8729	uri: GENERAL_CONTEXT_URI,
8730	mimeType: "application/json",
8731	text: JSON.stringify(buildPayload(), null, 2)
8732	}] };
8733	});
8734	(0, _elementor_editor_v1_adapters.__privateListenTo)([
8735	(0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/switch"),
8736	(0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview"),
8737	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/settings")
8738	], pushUpdateIfChanged);
8739	pushUpdateIfChanged();
8740	};
8741
8742	//#endregion
8743	//#region packages/packages/core/editor-canvas/src/mcp/resources/selected-element-resource.ts
8744	var SELECTED_ELEMENT_URI = "elementor://context/selected-element";
8745	var initSelectedElementResource = (reg) => {
8746	const { resource, sendResourceUpdated } = reg;
8747	let currentPayloadText = null;
8748	const publishIfChanged = (payload) => {
8749	const nextText = JSON.stringify(payload);
8750	if (nextText !== currentPayloadText) {
8751	currentPayloadText = nextText;
8752	sendResourceUpdated({ uri: SELECTED_ELEMENT_URI });
8753	}
8754	};
8755	const onCommand = (e) => {
8756	if (e.type !== "command") return;
8757	const commandEvent = e;
8758	if (commandEvent.command === "document/elements/deselect-all") {
8759	publishIfChanged(createEmptySelectedElementPayload());
8760	return;
8761	}
8762	if (commandEvent.command !== "document/elements/select" && commandEvent.command !== "document/elements/settings") return;
8763	const { container } = commandEvent.args \|\| {};
8764	if (container?.id) {
8765	publishIfChanged(buildPayloadFromContainer(container));
8766	return;
8767	}
8768	publishIfChanged(readSelectionFromEditor());
8769	};
8770	(0, _elementor_editor_v1_adapters.__privateListenTo)([
8771	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/select"),
8772	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/deselect-all"),
8773	(0, _elementor_editor_v1_adapters.commandEndEvent)("document/elements/settings")
8774	], onCommand);
8775	publishIfChanged(readSelectionFromEditor());
8776	resource("selected-element", SELECTED_ELEMENT_URI, { description: "Currently selected Elementor element context." }, async () => {
8777	return { contents: [{
8778	uri: SELECTED_ELEMENT_URI,
8779	text: JSON.stringify(readSelectionFromEditor(), null, 2)
8780	}] };
8781	});
8782	};
8783	function createEmptySelectedElementPayload() {
8784	return {
8785	elementDisplayName: null,
8786	elementType: null,
8787	properties: null,
8788	selectedElementId: null,
8789	selectedParentId: null,
8790	version: null,
8791	widgetType: null
8792	};
8793	}
8794	function readSelectionFromEditor() {
8795	const elements = (0, _elementor_editor_elements.getSelectedElements)();
8796	if (elements.length !== 1) return createEmptySelectedElementPayload();
8797	return buildPayloadFromContainer((0, _elementor_editor_elements.getContainer)(elements[0].id));
8798	}
8799	function buildPayloadFromContainer(container) {
8800	if (!container?.id) return createEmptySelectedElementPayload();
8801	const widgetType = container.model.get("widgetType") ?? null;
8802	const elementType = container.type ?? "widget";
8803	return {
8804	elementDisplayName: getElementDisplayName(container),
8805	elementType,
8806	properties: getElementProperties(container, widgetType),
8807	selectedElementId: container.id,
8808	selectedParentId: container.parent?.id ?? null,
8809	version: resolveElementVersion(container, widgetType),
8810	widgetType
8811	};
8812	}
8813	function resolveElementVersion(container, widgetType) {
8814	if (container.model?.config?.atomic) return "v4";
8815	if (widgetType && (0, _elementor_editor_elements.getWidgetsCache)()?.[widgetType]?.atomic_props_schema) return "v4";
8816	return "v3";
8817	}
8818	function getElementProperties(container, widgetType) {
8819	const settings = container.settings?.toJSON?.();
8820	if (!settings \|\| typeof settings !== "object") return null;
8821	const controls = (widgetType ? (0, _elementor_editor_elements.getWidgetsCache)()?.[widgetType] : null)?.controls;
8822	const filtered = {};
8823	for (const [key, value] of Object.entries(settings)) {
8824	if (value === void 0 \|\| value === null \|\| value === "") continue;
8825	const controlDefault = controls?.[key]?.default;
8826	if (controlDefault !== void 0 && JSON.stringify(value) === JSON.stringify(controlDefault)) continue;
8827	filtered[key] = value;
8828	}
8829	return Object.keys(filtered).length > 0 ? filtered : null;
8830	}
8831	function getElementDisplayName(container) {
8832	try {
8833	if (container.label) return container.label;
8834	const widgetType = container.model?.get?.("widgetType");
8835	if (widgetType) return (widgetType.charAt(0).toUpperCase() + widgetType.slice(1)).replace(/-/g, " ");
8836	if (container.type === "container") return "Container";
8837	if (container.type === "section") return "Section";
8838	return `Element ${container.id}`;
8839	} catch {
8840	return `Element ${container.id}`;
8841	}
8842	}
8843
8844	//#endregion
8845	//#region packages/packages/core/editor-canvas/src/mcp/utils/merge-custom-css.ts
8846	var CUSTOM_CSS_SEPARATOR = "\n";
8847	var mergeCustomCssText = (...cssParts) => cssParts.map((cssPart) => cssPart?.trim()).filter((cssPart) => !!cssPart).join(CUSTOM_CSS_SEPARATOR);
8848	var readStoredCustomCssText = (raw) => {
8849	if (!raw) return "";
8850	try {
8851	return atob(raw);
8852	} catch {
8853	return "";
8854	}
8855	};
8856
8857	//#endregion
8858	//#region packages/packages/core/editor-canvas/src/mcp/utils/resolve-canonical-prop-name.ts
8859	function buildAliasToCanonicalMap(schema) {
8860	const aliasToCanonical = {};
8861	for (const [canonical, propType] of Object.entries(schema)) {
8862	const aliases = propType.meta?.aliases;
8863	if (!Array.isArray(aliases)) continue;
8864	for (const alias of aliases) if (typeof alias === "string" && alias) aliasToCanonical[alias] = canonical;
8865	}
8866	return aliasToCanonical;
8867	}
8868	function resolveCanonicalPropName(elementType, propertyName) {
8869	const schema = (0, _elementor_editor_elements.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
8870	if (!schema \|\| schema[propertyName]) return propertyName;
8871	return buildAliasToCanonicalMap(schema)[propertyName] ?? propertyName;
8872	}
8873	function resolveCanonicalPropKeys(elementType, props) {
8874	const schema = (0, _elementor_editor_elements.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
8875	if (!schema) return { ...props };
8876	const aliasToCanonical = buildAliasToCanonicalMap(schema);
8877	const resolved = {};
8878	for (const [key, value] of Object.entries(props)) if (schema[key]) resolved[key] = value;
8879	for (const [key, value] of Object.entries(props)) {
8880	if (schema[key]) continue;
8881	const canonical = aliasToCanonical[key];
8882	if (!canonical) {
8883	resolved[key] = value;
8884	continue;
8885	}
8886	if (!Object.prototype.hasOwnProperty.call(resolved, canonical)) resolved[canonical] = value;
8887	}
8888	return resolved;
8889	}
8890
8891	//#endregion
8892	//#region packages/packages/core/editor-canvas/src/mcp/utils/resolve-dynamic-tag.ts
8893	var DYNAMIC_PROP_TYPE_KEY = "dynamic";
8894	var OMITTED_DYNAMIC_SETTING_KEYS = ["fallback"];
8895	var getAtomicDynamicTags = () => {
8896	return (0, _elementor_editor_v1_adapters.getElementorConfig)().atomicDynamicTags?.tags ?? {};
8897	};
8898	var getDynamicTagNamesByCategories = (categories) => {
8899	if (!categories.length) return [];
8900	const wanted = new Set(categories);
8901	return Object.values(getAtomicDynamicTags()).filter((tag) => tag.categories?.some((category) => wanted.has(category))).map((tag) => tag.name);
8902	};
8903	var dynamicTagLLMResolver = (value) => {
8904	const input = value ?? {};
8905	const tag = input.name ? getAtomicDynamicTags()[input.name] : void 0;
8906	if (!tag) return {
8907	$$type: DYNAMIC_PROP_TYPE_KEY,
8908	value: {
8909	name: input.name ?? "",
8910	group: "",
8911	settings: {}
8912	}
8913	};
8914	return {
8915	$$type: DYNAMIC_PROP_TYPE_KEY,
8916	value: {
8917	name: tag.name,
8918	group: tag.group,
8919	settings: buildStrictSettings(tag.props_schema ?? {}, input.settings ?? {})
8920	}
8921	};
8922	};
8923	var buildStrictSettings = (schema, provided) => {
8924	const settings = {};
8925	for (const [key, propType] of Object.entries(schema)) {
8926	if (OMITTED_DYNAMIC_SETTING_KEYS.includes(key)) continue;
8927	const resolved = provided[key] !== void 0 ? wrapSettingValue(provided[key], propType) : defaultSettingValue(propType);
8928	if (resolved !== void 0 && resolved !== null) settings[key] = resolved;
8929	}
8930	return settings;
8931	};
8932	var wrapSettingValue = (raw, propType) => {
8933	if (raw !== null && typeof raw === "object") return raw;
8934	return propType.key ? {
8935	$$type: propType.key,
8936	value: raw
8937	} : raw;
8938	};
8939	var defaultSettingValue = (propType) => {
8940	if (propType.initial_value !== null && propType.initial_value !== void 0) return propType.initial_value;
8941	if (propType.default !== null && propType.default !== void 0) return wrapSettingValue(propType.default, propType);
8942	};
8943
8944	//#endregion
8945	//#region packages/packages/core/editor-canvas/src/mcp/utils/do-update-element-property.ts
8946	var __defProp = Object.defineProperty;
8947	var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
8948	enumerable: true,
8949	configurable: true,
8950	writable: true,
8951	value
8952	}) : obj[key] = value;
8953	var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
8954	var LOCAL_STYLE_META = {
8955	breakpoint: "desktop",
8956	state: null
8957	};
8958	var UnsupportedPropertyError = class extends Error {
8959	constructor(elementType, propertyName, availableProperties) {
8960	super(`Property "${propertyName}" does not exist on element type "${elementType}". Available properties are: ${availableProperties.join(", ")}`);
8961	__publicField(this, "elementType");
8962	__publicField(this, "propertyName");
8963	this.name = "UnsupportedPropertyError";
8964	this.elementType = elementType;
8965	this.propertyName = propertyName;
8966	}
8967	};
8968	function resolvePropValue(value, forceKey) {
8969	const Utils = window.elementorV2.editorVariables.Utils;
8970	return _elementor_editor_props.Schema.adjustLlmPropValueSchema(value, {
8971	forceKey,
8972	transformers: {
8973	...Utils.globalVariablesLLMResolvers,
8974	[DYNAMIC_PROP_TYPE_KEY]: dynamicTagLLMResolver
8975	}
8976	});
8977	}
8978	var doUpdateElementProperty = (params) => {
8979	const { elementId, propertyValue, elementType, customCssWriteMode = "replace" } = params;
8980	const propertyName = params.propertyName === "_styles" ? params.propertyName : resolveCanonicalPropName(elementType, params.propertyName);
8981	if (propertyName === "_styles") {
8982	const elementStyles = (0, _elementor_editor_elements.getElementStyles)(elementId) \|\| {};
8983	const propertyMapValue = propertyValue;
8984	const styleSchema = (0, _elementor_editor_styles.getStylesSchema)();
8985	const transformedStyleValues = Object.fromEntries(Object.entries(propertyMapValue).map(([key, val]) => {
8986	if (key === "custom_css") return [key, val];
8987	const { key: propKey2, kind } = styleSchema?.[key] \|\| {};
8988	if (!propKey2 && kind !== "union") throw new Error(`_styles property ${key} is not supported.`);
8989	if (val === null) return [key, null];
8990	return [key, resolvePropValue(val, propKey2)];
8991	}));
8992	const localStyle = Object.values(elementStyles).find((style) => style.label === "local");
8993	const existingCustomCssText = localStyle ? readStoredCustomCssText((0, _elementor_editor_styles.getVariantByMeta)(localStyle, LOCAL_STYLE_META)?.custom_css?.raw) : "";
8994	let customCss;
8995	Object.keys(propertyMapValue).forEach((stylePropName) => {
8996	const propertyRawSchema = styleSchema[stylePropName];
8997	if (stylePropName === "custom_css") {
8998	let customCssValue = propertyMapValue[stylePropName];
8999	if (typeof customCssValue === "object" && customCssValue && customCssValue.value) customCssValue = String(customCssValue.value);
9000	if (!customCssValue) customCssValue = "";
9001	const customCssText = customCssWriteMode === "merge-with-stored" ? mergeCustomCssText(existingCustomCssText, customCssValue) : String(customCssValue);
9002	if (customCssText) customCss = { raw: btoa(customCssText) };
9003	else customCss = { raw: btoa("") };
9004	return;
9005	}
9006	if (!!!propertyRawSchema) throw new Error(`Style property ${stylePropName} is not supported.`);
9007	if (propertyRawSchema.kind === "plain") {
9008	if (typeof propertyMapValue[stylePropName] !== "object") {
9009	const propUtil = (0, _elementor_editor_props.getPropSchemaFromCache)(propertyRawSchema.key);
9010	if (propUtil) {
9011	const plainValue = propUtil.create(propertyMapValue[stylePropName]);
9012	propertyMapValue[stylePropName] = plainValue;
9013	}
9014	}
9015	}
9016	});
9017	delete transformedStyleValues.custom_css;
9018	if (!localStyle) (0, _elementor_editor_elements.createElementStyle)({
9019	elementId,
9020	...typeof customCss !== "undefined" ? { custom_css: customCss } : {},
9021	classesProp: "classes",
9022	label: "local",
9023	meta: {
9024	breakpoint: "desktop",
9025	state: null
9026	},
9027	props: { ...transformedStyleValues }
9028	});
9029	else (0, _elementor_editor_elements.updateElementStyle)({
9030	elementId,
9031	styleId: localStyle.id,
9032	meta: {
9033	breakpoint: "desktop",
9034	state: null
9035	},
9036	...typeof customCss !== "undefined" ? { custom_css: customCss } : {},
9037	props: { ...transformedStyleValues }
9038	});
9039	return;
9040	}
9041	const elementPropSchema = (0, _elementor_editor_elements.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
9042	if (!elementPropSchema) throw new Error(`No prop schema found for element type: ${elementType}`);
9043	if (!elementPropSchema[propertyName]) throw new UnsupportedPropertyError(elementType, propertyName, Object.keys(elementPropSchema));
9044	const propKey = elementPropSchema[propertyName].key;
9045	const value = resolvePropValue(propertyValue, propKey);
9046	const { valid, jsonSchema } = _elementor_editor_props.Schema.validatePropValue(elementPropSchema[propertyName], propertyValue);
9047	if (!valid) throw new Error(`Invalid PropValue for elementId: ${elementId}. PropKey: ${propKey}, PropValue: ${JSON.stringify(propertyValue)}
9048	Expected Schema: ${jsonSchema}`);
9049	(0, _elementor_editor_elements.updateElementSettings)({
9050	id: elementId,
9051	props: { [propertyName]: value },
9052	withHistory: false
9053	});
9054	(0, _elementor_editor_v1_adapters.__privateRunCommandSync)("document/save/set-is-modified", { status: true }, { internal: true });
9055	};
9056
9057	//#endregion
9058	//#region packages/packages/core/editor-canvas/src/mcp/tools/configure-element/prompt.ts
9059	var CONFIGURE_ELEMENT_GUIDE_URI = "elementor://canvas/tools/configure-element-guide";
9060	var generatePrompt = () => {
9061	const configureElementToolPrompt = (0, _elementor_editor_mcp.toolPrompts)("configure-element");
9062	configureElementToolPrompt.description(`
9063	Configure an existing element on the page.
9064
9065	# CRITICAL - REQUIRED INFORMATION (Must read before using this tool)
9066	1. [${WIDGET_SCHEMA_URI}] \u2014 Widget properties (\`propertiesToChange\`): each widgetType (e.g. e-heading, e-button) has its own PropType schema; values must be PropValues with \`$$type\`.
9067	2. [elementor://global-variables] \u2014 Design tokens for styling: use labels in CSS as \`var(--label)\` or \`var(--label, fallback)\`; only variables listed here are valid.
9068	3. Styling (\`style\` parameter): flat map of CSS property \u2192 value strings \u2014 not PropValues. The server converts to native styles; unconvertible declarations become custom CSS.
9069	4. Current state: \`get-element-configuration-values\` returns \`properties\` as PropValues and \`style\` in stored form; when writing, send raw CSS in \`style\`, not copied PropValues.
9070
9071	Before using this tool, read the widget PropType schema at editor-canvas__elementor://widgets/schema/{widgetType}
9072
9073	# When to use this tool
9074	When a user requires to change anything in an element, such as updating text, colors, sizes, or other configurable properties.
9075	This tool handles elements of type "widget".
9076	This tool handles styling elements, using the "style" parameter (raw CSS as a property \u2192 value map).
9077
9078	To CLEAR a property (i.e., set it to default or none), provide null as a value - example: \`background-color: null\`.
9079
9080	The element's schema must be known before using this tool.
9081
9082	PropValue structure (for \`propertiesToChange\` only \u2014 not for \`style\`):
9083	{
9084	"$$type": string, // MANDATORY as defined in the PropType schema under the "key" property
9085	value: unknown // The value according to the PropType schema for kinds of "array", use array with PropValues items inside. For "object", read the shape property of the PropType schema. For "plain", use strings.
9086	}
9087
9088	<IMPORTANT>
9089	ALWAYS MAKE SURE you have the PropType schemas for the element you are configuring. If you are not sure, retrieve the schema from the resources mentioned above.
9090	</IMPORTANT>
9091
9092	You can use multiple property changes at once by providing multiple entries in the propertiesToChange object.
9093	Some properties are nested, use the root property name, then objects with nested values inside, as the complete schema suggests.
9094
9095	Make sure you have the "widget-schema-by-type" resource available to retrieve the PropType schema for the element type you are configuring.
9096
9097	# How to configure elements
9098	We use a dedicated PropType Schema for configuring element properties (propertiesToChange). When you configure an element property, you must use the EXACT PropType Value as defined in the schema.
9099	For styling, use the "style" parameter with raw CSS declarations (property \u2192 value strings) - e.g. \`color: var(--primary-text, #000); height: 4rem;\`;
9100	For all non-primitive entries in \`propertiesToChange\`, provide the schema \`key\` as \`$$type\` in the generated object, as it is MANDATORY for parsing.
9101
9102	Use the EXACT PropType schema given, and ALWAYS include the \`key\` from the schema for every property you are changing in \`propertiesToChange\`.
9103
9104	# Dynamic tags
9105	A value can be made dynamic wherever its schema exposes a variant with "$$type": "dynamic". This may be the property root OR a NESTED field: for example an image is made dynamic on its "src" (the root stays "image"), NOT on the whole "image" value.
9106	Put the dynamic object EXACTLY at the node whose schema offers the "dynamic" variant, in place of the static variant. The variant's "name" enumerates the tags allowed at that node.
9107	1. Read the [${DYNAMIC_TAGS_URI}] resource for each allowed tag's settings schema.
9108	2. Provide, at that node:
9109	{
9110	"$$type": "dynamic",
9111	"value": {
9112	"name": "<allowed tag name>",
9113	"settings": { /* strictly per the tag's settings schema */ }
9114	}
9115	}
9116	Image example: { "$$type": "image", "value": { "src": { "$$type": "dynamic", "value": { "name": "<image tag>", "settings": { ... } } } } }
9117	Do NOT send "group" (it is resolved automatically). Use { "settings": {} } only when the tag has no settings.
9118	`);
9119	configureElementToolPrompt.parameter("elementId", "The ID of the element to configure. MANDATORY.");
9120	configureElementToolPrompt.parameter("elementType", "The type of the element to configure (i.e. e-heading, e-button). MANDATORY.");
9121	configureElementToolPrompt.parameter("propertiesToChange", "An object containing the properties to change, with their new values. MANDATORY. When updating a style only, provide an empty object.");
9122	configureElementToolPrompt.parameter("style", "A flat map of raw CSS declarations (property → value), e.g. { \"line-height\": \"1.25rem\", \"color\": \"var(--primary-text, #000)\" }. font-family must be a single Google Font name or a var(--label) — no fallback stacks. Set a value to null to reset that property to its default. OPTIONAL.");
9123	configureElementToolPrompt.example(`
9124	\`\`\`json
9125	{
9126	propertiesToChange: {
9127	// List of properties TO CHANGE, following the PropType schema for the element as defined in the resource [${WIDGET_SCHEMA_URI}]
9128	title: {
9129	$$type: 'string',
9130	value: 'New Title Text'
9131	},
9132	border: {
9133	$$type: 'boolean',
9134	value: false
9135	},
9136	},
9137	style: {
9138	'line-height': '1.25rem',
9139	'color': 'var(--primary-text, #000)'
9140	},
9141	elementId: 'element-id',
9142	elementType: 'element-type'
9143	};
9144	\`\`\`
9145	`);
9146	configureElementToolPrompt.instruction("The $$type property is MANDATORY for every value in propertiesToChange; it is not used in the style parameter (raw CSS only).");
9147	configureElementToolPrompt.instruction(`
9148	V4 only: If MCP fails, give manual steps using V4 UI.
9149
9150	V4 Editor structure:
9151	Panel tabs: General (\u2192 Settings section: ID, Tag, and Link where the widget supports it), Style, Interactions.
9152	NO Advanced tab. Never mention Advanced tab.
9153	Note: \`link\` is valid only when the element's PropType schema (which you must already have) includes a \`link\` property. Sending \`link\` to a widget whose schema lacks it is skipped and reported in the response \`warnings\` (other changes still apply) and the link is lost.
9154	`);
9155	return configureElementToolPrompt.prompt();
9156	};
9157
9158	//#endregion
9159	//#region packages/packages/core/editor-canvas/src/mcp/tools/configure-element/schema.ts
9160	var inputSchema = {
9161	propertiesToChange: _elementor_schema.z.record(_elementor_schema.z.string().describe("The property name."), _elementor_schema.z.any().describe(`PropValue, refer to [${WIDGET_SCHEMA_URI}] by correct type, as appears in elementType`), _elementor_schema.z.any()).describe("An object record containing property names and their new values to be set on the element"),
9162	style: _elementor_schema.z.record(_elementor_schema.z.string().describe("A CSS property name, e.g. \"color\", \"margin-top\"."), _elementor_schema.z.string().nullable().describe("A CSS value, e.g. \"red\", \"10px\", \"1px solid #000\". Use null to reset the property to its default.")).describe("Raw CSS declarations as a flat property→value map. Converted to native styles server-side; any declaration that cannot be converted is stored as the element custom CSS. A null value resets that property to its default.").default({}),
9163	elementType: _elementor_schema.z.string().describe("The type of the element to retrieve the schema"),
9164	elementId: _elementor_schema.z.string().describe("The unique id of the element to configure")
9165	};
9166	var outputSchema = {
9167	success: _elementor_schema.z.boolean().describe("Whether the configuration change was successful, only if propertyName and propertyValue are provided"),
9168	warnings: _elementor_schema.z.string().describe("Non-fatal notices. Present when some props were skipped because they are not in the element schema (e.g. a \"link\" on a widget with no link prop). Other changes were still applied.").optional()
9169	};
9170
9171	//#endregion
9172	//#region packages/packages/core/editor-canvas/src/mcp/tools/configure-element/tool.ts
9173	var initConfigureElementTool = (reg) => {
9174	const { addTool, resource } = reg;
9175	resource("configure-element-guide", CONFIGURE_ELEMENT_GUIDE_URI, {
9176	title: "Configure Element Guide",
9177	description: "Detailed guide for using the configure-element tool",
9178	mimeType: "text/plain"
9179	}, async (uri) => ({ contents: [{
9180	uri: uri.href,
9181	mimeType: "text/plain",
9182	text: generatePrompt()
9183	}] }));
9184	addTool({
9185	name: "configure-element",
9186	description: "Configure an existing V4 element's properties and styles. Read the guide resource before use.",
9187	schema: inputSchema,
9188	outputSchema,
9189	requiredResources: [
9190	{
9191	description: "Widgets schema",
9192	uri: WIDGET_SCHEMA_URI
9193	},
9194	{
9195	description: "Configure element guide",
9196	uri: CONFIGURE_ELEMENT_GUIDE_URI
9197	},
9198	{
9199	description: "Dynamic tags catalog",
9200	uri: DYNAMIC_TAGS_URI
9201	}
9202	],
9203	handler: async ({ elementId, propertiesToChange, elementType, style }) => {
9204	const widgetData = (0, _elementor_editor_elements.getWidgetsCache)()?.[elementType];
9205	if (!widgetData) throw new Error(`Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`);
9206	const container = (0, _elementor_editor_elements.getContainer)(elementId);
9207	if (!container) throw new Error(`Element with id ${elementId} not found`);
9208	if (!(container.settings.get("widgetType") === elementType \|\| container.type === elementType)) throw new Error(`Element with ID ${elementId} is not of type ${elementType}`);
9209	if (!widgetData.atomic_props_schema) throw new Error(`This tool does not support V3 elements. Please use the elementor-v3-mcp tools instead for element type: ${elementType}`);
9210	const propertiesToUpdate = resolveCanonicalPropKeys(elementType, propertiesToChange);
9211	const toUpdate = Object.entries(propertiesToUpdate);
9212	const skippedProps = [];
9213	for (const [propertyName, propertyValue] of toUpdate) {
9214	if (!_elementor_editor_props.Schema.isPropKeyConfigurable(propertyName)) throw new Error(`Not allowed to update ${propertyName}`);
9215	try {
9216	doUpdateElementProperty({
9217	elementId,
9218	elementType,
9219	propertyName,
9220	propertyValue
9221	});
9222	} catch (error) {
9223	if (error instanceof UnsupportedPropertyError) {
9224	skippedProps.push(error.propertyName);
9225	continue;
9226	}
9227	const errorMessage = createUpdateErrorMessage({
9228	propertyName,
9229	elementId,
9230	elementType,
9231	error,
9232	propertyType: "prop"
9233	});
9234	throw new Error(errorMessage);
9235	}
9236	}
9237	await applyStyleFromCss({
9238	elementId,
9239	elementType,
9240	style
9241	});
9242	return {
9243	success: true,
9244	warnings: skippedProps.length ? `Skipped unsupported props (not in the "${elementType}" schema; other changes were applied): ${skippedProps.join(", ")}.` : void 0
9245	};
9246	}
9247	});
9248	};
9249	async function applyStyleFromCss(opts) {
9250	const { elementId, elementType, style } = opts;
9251	if (!style \|\| Object.keys(style).length === 0) return;
9252	const { props, customCss } = await convertCssToAtomic(style);
9253	const styleValue = { ...props };
9254	if (customCss) styleValue.custom_css = customCss;
9255	if (Object.keys(styleValue).length === 0) return;
9256	try {
9257	doUpdateElementProperty({
9258	elementId,
9259	elementType,
9260	propertyName: "_styles",
9261	propertyValue: styleValue,
9262	customCssWriteMode: "merge-with-stored"
9263	});
9264	(0, _elementor_editor_mcp.dispatchMcpStylesAppliedEvent)({ styleValue });
9265	} catch (error) {
9266	throw new Error(createUpdateErrorMessage({
9267	propertyName: "(style)",
9268	elementId,
9269	elementType,
9270	propertyType: "style",
9271	error
9272	}));
9273	}
9274	}
9275	function createUpdateErrorMessage(opts) {
9276	const { propertyName, elementId, elementType, error, propertyType } = opts;
9277	return `Failed to update property "${propertyName}" on element "${elementId}": ${error.message}.
9278	${propertyType === "prop" ? `
9279	Check the element's PropType schema at the resource [${WIDGET_SCHEMA_URI.replace("{widgetType}", elementType)}] for type "${elementType}" to ensure the property exists and the value matches the expected PropType.
9280	Now that you have this information, ensure you have the schema and try again.` : `
9281	Provide styling as raw CSS via the "style" parameter (a flat map of CSS property \u2192 value). Declarations that cannot be converted are stored as the element custom CSS.`};
9282	}`;
9283	}
9284
9285	//#endregion
9286	//#region packages/packages/core/editor-canvas/src/mcp/utils/get-mcp-error-message.ts
9287	function getMcpErrorMessage(error, toolName) {
9288	if (error instanceof _elementor_http_client.AxiosError) {
9289	const data = error.response?.data;
9290	if (data?.message) return data.code ? `${data.code}: ${data.message}` : data.message;
9291	}
9292	if (error instanceof Error) return error.message;
9293	return `${toolName} failed with an unknown error.`;
9294	}
9295
9296	//#endregion
9297	//#region packages/packages/core/editor-canvas/src/mcp/tools/get-page-structure/tool.ts
9298	var MCP_PROXY_URL = "elementor/v1/mcp-proxy";
9299	var initGetPageStructureTool = (reg) => {
9300	const { addTool } = reg;
9301	addTool({
9302	name: "get-page-structure",
9303	description: "Returns a lean Elementor element tree skeleton (id, elType, widgetType, title, nested elements) for a post or page. If no postId is provided, uses the currently open document. Optionally scope to a subtree with elementId. Set includeContent=true (requires elementId) to also return each node's settings and styles.",
9304	schema: {
9305	postId: _elementor_schema.z.number().optional().describe("WordPress post ID of the Elementor document. If omitted, uses the currently open document."),
9306	elementId: _elementor_schema.z.string().optional().describe("If provided, returns only the subtree rooted at that element id."),
9307	includeContent: _elementor_schema.z.boolean().optional().describe("If true, includes each node's settings and styles (same shape build-composition accepts as input). Requires elementId.")
9308	},
9309	outputSchema: { elements: _elementor_schema.z.array(_elementor_schema.z.any()).describe("Skeleton of Elementor elements (id, elType, widgetType, title, nested elements). When includeContent is true, each node also includes settings and styles.") },
9310	handler: async ({ postId, elementId, includeContent }) => {
9311	const resolvedPostId = postId ?? (0, _elementor_editor_documents.getCurrentDocument)()?.id;
9312	if (!resolvedPostId) throw new Error("No post ID provided and no active document found.");
9313	try {
9314	const { data } = await (0, _elementor_http_client.httpService)().post(MCP_PROXY_URL, {
9315	tool: "get-page-structure",
9316	input: {
9317	post_id: resolvedPostId,
9318	...elementId ? { element_id: elementId } : {},
9319	...includeContent ? { include_content: true } : {}
9320	}
9321	});
9322	return { elements: data.data.elements };
9323	} catch (error) {
9324	throw new Error(getMcpErrorMessage(error, "get-page-structure"));
9325	}
9326	}
9327	});
9328	};
9329
9330	//#endregion
9331	//#region packages/packages/core/editor-canvas/src/mcp/canvas-mcp.ts
9332	var initCanvasMcp = (reg) => {
9333	_elementor_editor_props.Schema.setDynamicTagNamesResolver(getDynamicTagNamesByCategories);
9334	initWidgetsSchemaResource(reg);
9335	initAvailableWidgetsResource(reg);
9336	initDocumentStructureResource(reg);
9337	initDynamicTagsResource(reg);
9338	initSelectedElementResource(reg);
9339	initEditorStateResource(reg);
9340	initGeneralContextResource(reg);
9341	initBestPracticesResource(reg);
9342	initConfigureElementTool(reg);
9343	initGetPageStructureTool(reg);
9344	initBreakpointsResource(reg);
9345	};
9346
9347	//#endregion
9348	//#region packages/packages/core/editor-canvas/src/mcp/mcp-description.ts
9349	var ELEMENT_SCHEMA_URI = WIDGET_SCHEMA_URI.replace("{widgetType}", "element-schema");
9350	var mcpDescription = `Elementor Canvas MCP
9351	This MCP enables configuration and styling of existing V4 elements on the Elementor canvas using the configure-element tool.
9352
9353	# Core Concepts
9354
9355	## PropValues Structure
9356	All data in Elementor uses PropValues - a typed wrapper for values:
9357	\`\`\`json
9358	{
9359	"$$type": "the-prop-type-schema-kind",
9360	"value": "the-actual-value-as-defined-for-the-propType"
9361	}
9362	\`\`\`
9363	The \`$$type\` defines how Elementor interprets the value. Providing the correct \`$$type\` is critical - incorrect types will be rejected.
9364
9365	## Design System Resources
9366	- Global Variables: Reusable colors, sizes, and fonts (\`elementor://global-variables\`)
9367	- Global Classes: Reusable style sets that can be applied to elements (\`elementor://global-classes\`)
9368	- Widget Schemas: Configuration options for each widget type (\`${WIDGET_SCHEMA_URI}\`)
9369
9370	# Configuring Elements with configure-element
9371
9372	The \`configure-element\` tool updates settings and styles on existing V4 elements. Read the configure-element guide resource before use.
9373
9374	## Complete Workflow
9375
9376	### 1. Parse User Requirements
9377	Understand what needs to change: content, settings, or styling on existing elements.
9378
9379	### 2. Check Global Resources FIRST
9380	Always check existing resources before styling:
9381	- List \`elementor://global-variables\` for available variables (colors, sizes, fonts)
9382	- List \`elementor://global-classes\` for available style sets
9383	- Always prefer using existing global resources over creating inline styles
9384
9385	### 3. Retrieve Widget Schemas
9386	For each element you will configure:
9387	- List \`${WIDGET_SCHEMA_URI}\` to see available widgets
9388	- Retrieve configuration schema from \`${ELEMENT_SCHEMA_URI}\` for each widget
9389	- Check the \`llm_guidance\` property for container nesting, \`default_styles\`, and \`default_settings\`
9390
9391	### 4. Get Current Element State
9392	Use page structure and element configuration resources to find element IDs and current values.
9393
9394	### 5. Create propertiesToChange
9395	Map property names to PropValues using the widget schema:
9396	- Use correct \`$$type\` matching the widget's schema
9397	- Use global variables in PropValues where applicable
9398	- Example:
9399	\`\`\`json
9400	{
9401	"text": { "$$type": "string", "value": "Welcome" },
9402	"tag": { "$$type": "string", "value": "h1" }
9403	}
9404	\`\`\`
9405
9406	### 6. Create style
9407	Provide raw CSS declarations (property \u2192 value strings). The server converts them to native styles and stores any unconvertible declarations as the element custom CSS.
9408	- Example:
9409	\`\`\`json
9410	{
9411	"color": "#1a1a1a",
9412	"font-size": "2rem"
9413	}
9414	\`\`\`
9415
9416	### 7. Execute configure-element
9417	Call the tool with elementId, elementType, propertiesToChange, and style as needed.
9418
9419	## Key Points
9420
9421	- PropValue Types: Arrays that accept union types are typed as mixed arrays
9422	- Visual Sizing: Widget sizes MUST be defined via the style parameter (raw CSS). Widget properties like image "size" control resolution, not visual appearance
9423	- Global Variables: Reference by label/name: (e.g. var(--card-background-color)
9424	- Naming Conventions: Use meaningful, purpose-based names (e.g., "primary-button", "heading-large"), not value-based names (e.g., "blue-style", "20px-padding")
9425
9426	## Example: e-image PropValue Structure
9427	\`\`\`json
9428	{
9429	"$$type": "image",
9430	"value": {
9431	"src": {
9432	"$$type": "image-src",
9433	"value": {
9434	"url": { "$$type": "url", "value": "https://example.com/image.jpg" }
9435	}
9436	},
9437	"size": { "$$type": "string", "value": "full" }
9438	}
9439	}
9440	\`\`\`
9441	Note: The "size" property controls image resolution/loading, not visual size. Set visual dimensions via the style parameter (raw CSS).
9442	`;
9443
9444	//#endregion
9445	//#region packages/packages/core/editor-canvas/src/prevent-link-in-link-commands.ts
9446	function initLinkInLinkPrevention() {
9447	(0, _elementor_editor_v1_adapters.blockCommand)({
9448	command: "document/elements/paste",
9449	condition: blockLinkInLinkPaste
9450	});
9451	(0, _elementor_editor_v1_adapters.blockCommand)({
9452	command: "document/elements/move",
9453	condition: blockLinkInLinkMove
9454	});
9455	}
9456	var learnMoreActionProps = {
9457	href: "https://go.elementor.com/element-link-inside-link-infotip",
9458	target: "_blank",
9459	color: "inherit",
9460	variant: "text",
9461	sx: { marginInlineStart: "20px" },
9462	children: "Learn more"
9463	};
9464	function blockLinkInLinkPaste(args) {
9465	const { containers = [args.container], storageType } = args;
9466	const targetElements = containers;
9467	if (storageType !== "localstorage") return false;
9468	const data = window?.elementorCommon?.storage?.get();
9469	if (!data?.clipboard?.elements) return false;
9470	const sourceElements = data.clipboard.elements;
9471	const notification = {
9472	type: "default",
9473	message: (0, _wordpress_i18n.__)("To paste a link to this element, first remove the link from it's parent container.", "elementor"),
9474	id: "paste-in-link-blocked",
9475	additionalActionProps: [learnMoreActionProps]
9476	};
9477	const blocked = shouldBlock(sourceElements, targetElements);
9478	if (blocked) (0, _elementor_editor_notifications.notify)(notification);
9479	return blocked;
9480	}
9481	function blockLinkInLinkMove(args) {
9482	const { containers = [args.container], target } = args;
9483	const sourceElements = containers;
9484	const targetElement = target;
9485	const notification = {
9486	type: "default",
9487	message: (0, _wordpress_i18n.__)("To drag a link to this element, first remove the link from it's parent container.", "elementor"),
9488	id: "move-in-link-blocked",
9489	additionalActionProps: [learnMoreActionProps]
9490	};
9491	const isBlocked = shouldBlock(sourceElements, [targetElement]);
9492	if (isBlocked) (0, _elementor_editor_notifications.notify)(notification);
9493	return isBlocked;
9494	}
9495	function shouldBlock(sourceElements, targetElements) {
9496	if (!sourceElements?.length \|\| !targetElements?.length) return false;
9497	if (!sourceElements.some((src) => {
9498	return src?.id ? (0, _elementor_editor_elements.isElementAnchored)(src.id) \|\| !!(0, _elementor_editor_elements.getAnchoredDescendantId)(src.id) : false;
9499	})) return false;
9500	return targetElements.some((target) => {
9501	return target?.id ? (0, _elementor_editor_elements.isElementAnchored)(target.id) \|\| !!(0, _elementor_editor_elements.getAnchoredAncestorId)(target.id) : false;
9502	});
9503	}
9504
9505	//#endregion
9506	//#region packages/packages/core/editor-canvas/src/utils/command-utils.ts
9507	function hasAtomicWidgets(args) {
9508	const { containers = [args.container] } = args;
9509	return containers.some(isAtomicWidget);
9510	}
9511	function isAtomicWidget(container) {
9512	if (!container) return false;
9513	return Boolean(getContainerSchema(container));
9514	}
9515	function getClassesProp(container) {
9516	const propsSchema = getContainerSchema(container);
9517	if (!propsSchema) return null;
9518	const [propKey] = Object.entries(propsSchema).find(([, propType]) => propType.kind === "plain" && propType.key === _elementor_editor_props.CLASSES_PROP_KEY) ?? [];
9519	return propKey ?? null;
9520	}
9521	function getContainerSchema(container) {
9522	const type = container?.model.get("widgetType") \|\| container?.model.get("elType");
9523	return ((0, _elementor_editor_elements.getWidgetsCache)()?.[type])?.atomic_props_schema ?? null;
9524	}
9525	function getClipboardElements(storageKey = "clipboard") {
9526	try {
9527	return JSON.parse(localStorage.getItem("elementor") ?? "{}")[storageKey]?.elements;
9528	} catch {
9529	return;
9530	}
9531	}
9532	function getTitleForContainers(containers) {
9533	return containers.length > 1 ? (0, _wordpress_i18n.__)("Elements", "elementor") : (0, _elementor_editor_elements.getElementLabel)(containers[0].id);
9534	}
9535
9536	//#endregion
9537	//#region packages/packages/core/editor-canvas/src/style-commands/undoable-actions/paste-element-style.ts
9538	var undoablePasteElementStyle = () => (0, _elementor_editor_v1_adapters.undoable)({
9539	do: ({ containers, newStyle }) => {
9540	return containers.map((container) => {
9541	const elementId = container.id;
9542	const classesProp = getClassesProp(container);
9543	if (!classesProp) return null;
9544	const originalStyles = (0, _elementor_editor_elements.getElementStyles)(container.id);
9545	const [styleId, styleDef] = Object.entries(originalStyles ?? {})[0] ?? [];
9546	const revertData = {
9547	styleId,
9548	originalStyle: Object.keys(styleDef ?? {}).length ? styleDef : null
9549	};
9550	if (styleId) newStyle.variants.forEach(({ meta, props, custom_css: customCss }) => {
9551	(0, _elementor_editor_elements.updateElementStyle)({
9552	elementId,
9553	styleId,
9554	meta,
9555	props,
9556	custom_css: customCss
9557	});
9558	});
9559	else {
9560	const [firstVariant] = newStyle.variants;
9561	const additionalVariants = newStyle.variants.slice(1);
9562	revertData.styleId = (0, _elementor_editor_elements.createElementStyle)({
9563	elementId,
9564	classesProp,
9565	label: _elementor_editor_styles_repository.ELEMENTS_STYLES_RESERVED_LABEL,
9566	...firstVariant,
9567	additionalVariants
9568	});
9569	}
9570	return revertData;
9571	});
9572	},
9573	undo: ({ containers }, revertDataItems) => {
9574	containers.forEach((container, index) => {
9575	const revertData = revertDataItems[index];
9576	if (!revertData) return;
9577	if (!revertData.originalStyle) {
9578	(0, _elementor_editor_elements.deleteElementStyle)(container.id, revertData.styleId);
9579	return;
9580	}
9581	const classesProp = getClassesProp(container);
9582	if (!classesProp) return;
9583	const [firstVariant] = revertData.originalStyle.variants;
9584	const additionalVariants = revertData.originalStyle.variants.slice(1);
9585	(0, _elementor_editor_elements.createElementStyle)({
9586	elementId: container.id,
9587	classesProp,
9588	label: _elementor_editor_styles_repository.ELEMENTS_STYLES_RESERVED_LABEL,
9589	styleId: revertData.styleId,
9590	...firstVariant,
9591	additionalVariants
9592	});
9593	});
9594	}
9595	}, {
9596	title: ({ containers }) => getTitleForContainers(containers),
9597	subtitle: (0, _wordpress_i18n.__)("Style Pasted", "elementor")
9598	});
9599
9600	//#endregion
9601	//#region packages/packages/core/editor-canvas/src/style-commands/paste-style.ts
9602	function initPasteStyleCommand() {
9603	const pasteElementStyleCommand = undoablePasteElementStyle();
9604	(0, _elementor_editor_v1_adapters.blockCommand)({
9605	command: "document/elements/paste-style",
9606	condition: hasAtomicWidgets
9607	});
9608	(0, _elementor_editor_v1_adapters.__privateListenTo)((0, _elementor_editor_v1_adapters.commandStartEvent)("document/elements/paste-style"), (e) => pasteStyles(e.args, pasteElementStyleCommand));
9609	}
9610	function pasteStyles(args, pasteLocalStyle) {
9611	const { containers = [args.container], storageKey } = args;
9612	const atomicContainers = containers.filter(isAtomicWidget);
9613	if (!atomicContainers.length) return;
9614	const [clipboardElement] = getClipboardElements(storageKey) ?? [];
9615	const clipboardContainer = (0, _elementor_editor_elements.getContainer)(clipboardElement.id);
9616	if (!clipboardElement \|\| !clipboardContainer \|\| !isAtomicWidget(clipboardContainer)) return;
9617	const elementStyles = clipboardElement.styles;
9618	const elementStyle = Object.values(elementStyles ?? {})[0];
9619	const classesSetting = getClassesWithoutLocalStyle(clipboardContainer, elementStyle);
9620	if (classesSetting.length) pasteClasses(atomicContainers, classesSetting);
9621	if (elementStyle) pasteLocalStyle({
9622	containers: atomicContainers,
9623	newStyle: elementStyle
9624	});
9625	}
9626	function getClassesWithoutLocalStyle(clipboardContainer, style) {
9627	const classesProp = getClassesProp(clipboardContainer);
9628	if (!classesProp) return [];
9629	return (0, _elementor_editor_elements.getElementSetting)(clipboardContainer.id, classesProp)?.value.filter((styleId) => styleId !== style?.id) ?? [];
9630	}
9631	function pasteClasses(containers, classes) {
9632	containers.forEach((container) => {
9633	const classesProp = getClassesProp(container);
9634	if (!classesProp) return;
9635	const classesSetting = (0, _elementor_editor_elements.getElementSetting)(container.id, classesProp);
9636	const currentClasses = _elementor_editor_props.classesPropTypeUtil.extract(classesSetting) ?? [];
9637	const newClasses = _elementor_editor_props.classesPropTypeUtil.create(Array.from(/* @__PURE__ */ new Set([...classes, ...currentClasses])));
9638	(0, _elementor_editor_elements.updateElementSettings)({
9639	id: container.id,
9640	props: { [classesProp]: newClasses }
9641	});
9642	});
9643	}
9644
9645	//#endregion
9646	//#region packages/packages/core/editor-canvas/src/style-commands/undoable-actions/reset-element-style.ts
9647	var undoableResetElementStyle = () => (0, _elementor_editor_v1_adapters.undoable)({
9648	do: ({ containers }) => {
9649	return containers.map((container) => {
9650	const elementId = container.model.get("id");
9651	const containerStyles = (0, _elementor_editor_elements.getElementStyles)(elementId);
9652	Object.keys(containerStyles ?? {}).forEach((styleId) => (0, _elementor_editor_elements.deleteElementStyle)(elementId, styleId));
9653	return containerStyles;
9654	});
9655	},
9656	undo: ({ containers }, revertDataItems) => {
9657	containers.forEach((container, index) => {
9658	const classesProp = getClassesProp(container);
9659	if (!classesProp) return;
9660	const elementId = container.model.get("id");
9661	const containerStyles = revertDataItems[index];
9662	Object.entries(containerStyles ?? {}).forEach(([styleId, style]) => {
9663	const [firstVariant] = style.variants;
9664	const additionalVariants = style.variants.slice(1);
9665	(0, _elementor_editor_elements.createElementStyle)({
9666	elementId,
9667	classesProp,
9668	styleId,
9669	label: _elementor_editor_styles_repository.ELEMENTS_STYLES_RESERVED_LABEL,
9670	...firstVariant,
9671	additionalVariants
9672	});
9673	});
9674	});
9675	}
9676	}, {
9677	title: ({ containers }) => getTitleForContainers(containers),
9678	subtitle: (0, _wordpress_i18n.__)("Style Reset", "elementor")
9679	});
9680
9681	//#endregion
9682	//#region packages/packages/core/editor-canvas/src/style-commands/reset-style.ts
9683	function initResetStyleCommand() {
9684	const resetElementStyles = undoableResetElementStyle();
9685	(0, _elementor_editor_v1_adapters.blockCommand)({
9686	command: "document/elements/reset-style",
9687	condition: hasAtomicWidgets
9688	});
9689	(0, _elementor_editor_v1_adapters.__privateListenTo)((0, _elementor_editor_v1_adapters.commandStartEvent)("document/elements/reset-style"), (e) => resetStyles(e.args, resetElementStyles));
9690	}
9691	function resetStyles(args, resetElementStyles) {
9692	const { containers = [args.container] } = args;
9693	const atomicContainers = containers.filter(isAtomicWidget);
9694	if (!atomicContainers.length) return;
9695	resetElementStyles({ containers: atomicContainers });
9696	}
9697
9698	//#endregion
9699	//#region packages/packages/core/editor-canvas/src/style-commands/init-style-commands.ts
9700	function initStyleCommands() {
9701	initPasteStyleCommand();
9702	initResetStyleCommand();
9703	}
9704
9705	//#endregion
9706	//#region packages/packages/core/editor-canvas/src/init.tsx
9707	function init() {
9708	initStyleTransformers();
9709	initStyleCommands();
9710	initLinkInLinkPrevention();
9711	initFormNestingPrevention();
9712	initFormAncestorEnforcement();
9713	initViewReplacements();
9714	initLegacyViews();
9715	initSettingsTransformers();
9716	(0, _elementor_editor.injectIntoTop)({
9717	id: "elements-overlays",
9718	component: ElementsOverlays
9719	});
9720	(0, _elementor_editor.injectIntoTop)({
9721	id: "canvas-style-render",
9722	component: StyleRenderer
9723	});
9724	(0, _elementor_editor.injectIntoTop)({
9725	id: "canvas-interactions-render",
9726	component: InteractionsRenderer
9727	});
9728	(0, _elementor_editor.injectIntoLogic)({
9729	id: "classes-rename",
9730	component: ClassesRename
9731	});
9732	initCanvasMcp((0, _elementor_editor_mcp.getMCPByDomain)("canvas", {
9733	instructions: `Everything related to V4 ( Atomic ) canvas.
9734	# Canvas workflow
9735	- Configure element settings and styles with configure-element
9736	- Get page structure and element configuration values
9737	`,
9738	docs: mcpDescription
9739	}));
9740	initTabsModelExtensions();
9741	initListType();
9742	}
9743
9744	//#endregion
9745	//#region packages/packages/core/editor-canvas/src/sync/drag-element-from-panel.ts
9746	var DRAG_GROUPS = ["elementor-element"];
9747	var endDragElementFromPanel = () => {
9748	getElementorChannels()?.panelElements?.trigger("element:drag:end");
9749	};
9750	var startDragElementFromPanel = (props, event) => {
9751	setDragGroups(event);
9752	const channels = getElementorChannels();
9753	channels?.editor.reply("element:dragged", null);
9754	channels?.panelElements.reply("element:selected", getLegacyPanelElementView(props)).trigger("element:drag:start");
9755	};
9756	var setDragGroups = (event) => {
9757	const dataContainer = { groups: getDragGroups(event) };
9758	event.dataTransfer?.setData(JSON.stringify(dataContainer), "true");
9759	};
9760	var getDragGroups = (event) => {
9761	const dataContainer = event.dataTransfer?.getData("text/plain");
9762	return dataContainer ? JSON.parse(dataContainer).groups : DRAG_GROUPS;
9763	};
9764	var getElementorChannels = () => {
9765	const channels = window.elementor?.channels;
9766	if (!channels) throw new Error("Elementor channels not found: Elementor editor is not initialized or channels are unavailable.");
9767	return channels;
9768	};
9769	var getLegacyPanelElementView = ({ settings, ...rest }) => {
9770	const LegacyElementModel = window.elementor?.modules?.elements?.models?.Element;
9771	if (!LegacyElementModel) throw new Error("Elementor legacy Element model not found in editor modules");
9772	return { model: new LegacyElementModel({
9773	...rest,
9774	custom: {
9775	isPreset: !!settings,
9776	preset_settings: settings
9777	}
9778	}) };
9779	};
9780
9781	//#endregion
9782	//#region packages/packages/core/editor-canvas/src/sync/global-styles-imported-event.ts
9783	var GLOBAL_STYLES_IMPORTED_EVENT = "elementor/global-styles/imported";
9784
9785	//#endregion
9786	//#region packages/packages/core/editor-canvas/src/components/spotlight-backdrop.tsx
9787	function SpotlightBackdrop({ canvas, element, onExit, ariaLabel }) {
9788	const rect = useElementRect(element);
9789	const backdropStyle = {
9790	position: "fixed",
9791	top: 0,
9792	left: 0,
9793	width: "100vw",
9794	height: "100vh",
9795	backgroundColor: "rgba(0, 0, 0, 0.5)",
9796	zIndex: 999,
9797	pointerEvents: "painted",
9798	cursor: "pointer",
9799	clipPath: element ? getRectClipPath(rect, canvas.defaultView) : void 0
9800	};
9801	const handleKeyDown = (event) => {
9802	if (event.key === "Enter" \|\| event.key === " ") {
9803	event.preventDefault();
9804	onExit();
9805	}
9806	};
9807	return /* @__PURE__ */ react.createElement("div", {
9808	style: backdropStyle,
9809	onClick: onExit,
9810	onKeyDown: handleKeyDown,
9811	role: "button",
9812	tabIndex: 0,
9813	"aria-label": ariaLabel
9814	});
9815	}
9816	function getRectClipPath(rect, viewport) {
9817	const { x, y, width, height } = rect;
9818	const { innerWidth: vw, innerHeight: vh } = viewport;
9819	return `path(evenodd, 'M 0 0 L ${vw} 0 L ${vw} ${vh} L 0 ${vh} Z M ${x} ${y} L ${x + width} ${y} L ${x + width} ${y + height} L ${x} ${y + height} L ${x} ${y} Z')`;
9820	}
9821
9822	//#endregion
9823	//#region packages/packages/core/editor-canvas/src/hooks/use-canvas-document.ts
9824	function useCanvasDocument() {
9825	return (0, _elementor_editor_v1_adapters.__privateUseListenTo)((0, _elementor_editor_v1_adapters.commandEndEvent)("editor/documents/attach-preview"), () => (0, _elementor_editor_v1_adapters.getCanvasIframeDocument)());
9826	}
9827
9828	//#endregion
9829	//#region packages/packages/core/editor-canvas/src/hooks/use-escape-on-canvas.ts
9830	function useEscapeOnCanvas(canvasDocument, onEscape) {
9831	(0, react.useEffect)(() => {
9832	if (!canvasDocument) return;
9833	const handleEsc = (event) => {
9834	if (event.key === "Escape") onEscape();
9835	};
9836	canvasDocument.body.addEventListener("keydown", handleEsc);
9837	return () => {
9838	canvasDocument.body.removeEventListener("keydown", handleEsc);
9839	};
9840	}, [canvasDocument, onEscape]);
9841	}
9842
9843	//#endregion
9844	//#region packages/packages/core/editor-canvas/src/utils/after-render.ts
9845	function doAfterRender(elementIds, callback) {
9846	const pending = elementIds.map((elementId) => {
9847	const view = (0, _elementor_editor_elements.getContainer)(elementId)?.view;
9848	if (!view \|\| !hasDoAfterRender(view)) return;
9849	return new Promise((resolve) => view._doAfterRender(resolve));
9850	}).filter(Boolean);
9851	if (pending.length > 0) Promise.all(pending).then(() => callback(elementIds));
9852	else callback(elementIds);
9853	}
9854	function hasDoAfterRender(view) {
9855	return typeof view?._doAfterRender === "function";
9856	}
9857
9858	//#endregion
9859	//#region packages/packages/core/editor-canvas/src/sync/element-added-event.ts
9860	var ELEMENT_ADDED_EVENT = "elementor/canvas/element-added";
9861
9862	//#endregion
9863	//#region packages/packages/core/editor-canvas/src/index.ts
9864	var src_exports = /* @__PURE__ */ __exportAll({
9865	BREAKPOINTS_SCHEMA_FULL_URI: () => BREAKPOINTS_SCHEMA_FULL_URI,
9866	BREAKPOINTS_SCHEMA_URI: () => BREAKPOINTS_SCHEMA_URI,
9867	DOCUMENT_STRUCTURE_URI: () => DOCUMENT_STRUCTURE_URI,
9868	ELEMENT_ADDED_EVENT: () => ELEMENT_ADDED_EVENT,
9869	GLOBAL_STYLES_IMPORTED_EVENT: () => GLOBAL_STYLES_IMPORTED_EVENT,
9870	SpotlightBackdrop: () => SpotlightBackdrop,
9871	UnknownStyleStateError: () => UnknownStyleStateError,
9872	UnknownStyleTypeError: () => UnknownStyleTypeError,
9873	WIDGET_SCHEMA_FULL_URI: () => WIDGET_SCHEMA_FULL_URI,
9874	WIDGET_SCHEMA_URI: () => WIDGET_SCHEMA_URI,
9875	canBeNestedTemplated: () => canBeNestedTemplated,
9876	convertCssToAtomic: () => convertCssToAtomic,
9877	convertStyleBlocksToAtomic: () => convertStyleBlocksToAtomic,
9878	createNestedTemplatedElementType: () => createNestedTemplatedElementType,
9879	createNestedTemplatedElementView: () => createNestedTemplatedElementView,
9880	createPropsResolver: () => createPropsResolver,
9881	createTemplatedElementView: () => createTemplatedElementView,
9882	createTransformer: () => createTransformer,
9883	createTransformersRegistry: () => createTransformersRegistry,
9884	doAfterRender: () => doAfterRender,
9885	endDragElementFromPanel: () => endDragElementFromPanel,
9886	formatGridTrackRepeat: () => formatGridTrackRepeat,
9887	init: () => init,
9888	isAtomicWidget: () => isAtomicWidget,
9889	isGridTrackProperty: () => isGridTrackProperty,
9890	registerElementType: () => registerElementType,
9891	registerModelExtensions: () => registerModelExtensions,
9892	settingsTransformersRegistry: () => settingsTransformersRegistry,
9893	startDragElementFromPanel: () => startDragElementFromPanel,
9894	styleTransformersRegistry: () => styleTransformersRegistry,
9895	stylesInheritanceTransformersRegistry: () => stylesInheritanceTransformersRegistry,
9896	useCanvasDocument: () => useCanvasDocument,
9897	useEscapeOnCanvas: () => useEscapeOnCanvas,
9898	waitForChildrenToComplete: () => waitForChildrenToComplete
9899	});
9900
9901	//#endregion
9902	//#region \0elementor-package-library-entry
9903	(window.elementorV2 = window.elementorV2 \|\| {}).editorCanvas = src_exports;
9904
9905	//#endregion
9906	})(elementorV2.editorV1Adapters, elementorV2.editorMcp, elementorV2.httpClient, elementorV2.editor, React, elementorV2.editorDocuments, elementorV2.editorStylesRepository, elementorV2.utils, elementorV2.editorElements, elementorV2.ui, ReactDOM, elementorV2.editorInteractions, elementorV2.editorResponsive, elementorV2.editorStyles, elementorV2.editorProps, elementorV2.editorNotifications, wp.i18n, elementorV2.wpMedia, elementorV2.editorControls, elementorV2.twing, elementorV2.schema);
9907	window.elementorV2.editorCanvas?.init?.();
9908	//# sourceMappingURL=editor-canvas.js.map