Gutenberg / 18.6.1

Gutenberg v18.6.1

gutenberg / build / element / index.js

index.js in Gutenberg 18.6.1, at build/element/index.js

1,896 lines 65.3 KB

Raw Download Zip

1	/******/ (() => { // webpackBootstrap
2	/******/ "use strict";
3	/******/ var __webpack_modules__ = ({
4
5	/***/ 4470:
6	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
7
8
9
10	var m = __webpack_require__(1850);
11	if (true) {
12	exports.s = m.createRoot;
13	exports.a = m.hydrateRoot;
14	} else { var i; }
15
16
17	/***/ }),
18
19	/***/ 1850:
20	/***/ ((module) => {
21
22	module.exports = window["ReactDOM"];
23
24	/***/ })
25
26	/******/ });
27	/************************************************************************/
28	/******/ // The module cache
29	/******/ var __webpack_module_cache__ = {};
30	/******/
31	/******/ // The require function
32	/******/ function __webpack_require__(moduleId) {
33	/******/ // Check if module is in cache
34	/******/ var cachedModule = __webpack_module_cache__[moduleId];
35	/******/ if (cachedModule !== undefined) {
36	/******/ return cachedModule.exports;
37	/******/ }
38	/******/ // Create a new module (and put it into the cache)
39	/******/ var module = __webpack_module_cache__[moduleId] = {
40	/******/ // no module.id needed
41	/******/ // no module.loaded needed
42	/******/ exports: {}
43	/******/ };
44	/******/
45	/******/ // Execute the module function
46	/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
47	/******/
48	/******/ // Return the exports of the module
49	/******/ return module.exports;
50	/******/ }
51	/******/
52	/************************************************************************/
53	/*****/ / webpack/runtime/define property getters */
54	/******/ (() => {
55	/******/ // define getter functions for harmony exports
56	/******/ __webpack_require__.d = (exports, definition) => {
57	/******/ for(var key in definition) {
58	/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
59	/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
60	/******/ }
61	/******/ }
62	/******/ };
63	/******/ })();
64	/******/
65	/*****/ / webpack/runtime/hasOwnProperty shorthand */
66	/******/ (() => {
67	/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
68	/******/ })();
69	/******/
70	/*****/ / webpack/runtime/make namespace object */
71	/******/ (() => {
72	/******/ // define __esModule on exports
73	/******/ __webpack_require__.r = (exports) => {
74	/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
75	/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
76	/******/ }
77	/******/ Object.defineProperty(exports, '__esModule', { value: true });
78	/******/ };
79	/******/ })();
80	/******/
81	/************************************************************************/
82	var __webpack_exports__ = {};
83	// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
84	(() => {
85	// ESM COMPAT FLAG
86	__webpack_require__.r(__webpack_exports__);
87
88	// EXPORTS
89	__webpack_require__.d(__webpack_exports__, {
90	Children: () => (/* reexport */ external_React_namespaceObject.Children),
91	Component: () => (/* reexport */ external_React_namespaceObject.Component),
92	Fragment: () => (/* reexport */ external_React_namespaceObject.Fragment),
93	Platform: () => (/* reexport */ platform),
94	PureComponent: () => (/* reexport */ external_React_namespaceObject.PureComponent),
95	RawHTML: () => (/* reexport */ RawHTML),
96	StrictMode: () => (/* reexport */ external_React_namespaceObject.StrictMode),
97	Suspense: () => (/* reexport */ external_React_namespaceObject.Suspense),
98	cloneElement: () => (/* reexport */ external_React_namespaceObject.cloneElement),
99	concatChildren: () => (/* reexport */ concatChildren),
100	createContext: () => (/* reexport */ external_React_namespaceObject.createContext),
101	createElement: () => (/* reexport */ external_React_namespaceObject.createElement),
102	createInterpolateElement: () => (/* reexport */ create_interpolate_element),
103	createPortal: () => (/* reexport */ external_ReactDOM_.createPortal),
104	createRef: () => (/* reexport */ external_React_namespaceObject.createRef),
105	createRoot: () => (/* reexport / client/ createRoot */.s),
106	findDOMNode: () => (/* reexport */ external_ReactDOM_.findDOMNode),
107	flushSync: () => (/* reexport */ external_ReactDOM_.flushSync),
108	forwardRef: () => (/* reexport */ external_React_namespaceObject.forwardRef),
109	hydrate: () => (/* reexport */ external_ReactDOM_.hydrate),
110	hydrateRoot: () => (/* reexport / client/ hydrateRoot */.a),
111	isEmptyElement: () => (/* reexport */ isEmptyElement),
112	isValidElement: () => (/* reexport */ external_React_namespaceObject.isValidElement),
113	lazy: () => (/* reexport */ external_React_namespaceObject.lazy),
114	memo: () => (/* reexport */ external_React_namespaceObject.memo),
115	render: () => (/* reexport */ external_ReactDOM_.render),
116	renderToString: () => (/* reexport */ serialize),
117	startTransition: () => (/* reexport */ external_React_namespaceObject.startTransition),
118	switchChildrenNodeName: () => (/* reexport */ switchChildrenNodeName),
119	unmountComponentAtNode: () => (/* reexport */ external_ReactDOM_.unmountComponentAtNode),
120	useCallback: () => (/* reexport */ external_React_namespaceObject.useCallback),
121	useContext: () => (/* reexport */ external_React_namespaceObject.useContext),
122	useDebugValue: () => (/* reexport */ external_React_namespaceObject.useDebugValue),
123	useDeferredValue: () => (/* reexport */ external_React_namespaceObject.useDeferredValue),
124	useEffect: () => (/* reexport */ external_React_namespaceObject.useEffect),
125	useId: () => (/* reexport */ external_React_namespaceObject.useId),
126	useImperativeHandle: () => (/* reexport */ external_React_namespaceObject.useImperativeHandle),
127	useInsertionEffect: () => (/* reexport */ external_React_namespaceObject.useInsertionEffect),
128	useLayoutEffect: () => (/* reexport */ external_React_namespaceObject.useLayoutEffect),
129	useMemo: () => (/* reexport */ external_React_namespaceObject.useMemo),
130	useReducer: () => (/* reexport */ external_React_namespaceObject.useReducer),
131	useRef: () => (/* reexport */ external_React_namespaceObject.useRef),
132	useState: () => (/* reexport */ external_React_namespaceObject.useState),
133	useSyncExternalStore: () => (/* reexport */ external_React_namespaceObject.useSyncExternalStore),
134	useTransition: () => (/* reexport */ external_React_namespaceObject.useTransition)
135	});
136
137	;// CONCATENATED MODULE: external "React"
138	const external_React_namespaceObject = window["React"];
139	;// CONCATENATED MODULE: ./packages/element/build-module/create-interpolate-element.js
140	/**
141	* Internal dependencies
142	*/
143
144
145	/**
146	* Object containing a React element.
147	*
148	* @typedef {import('react').ReactElement} Element
149	*/
150
151	let indoc, offset, output, stack;
152
153	/**
154	* Matches tags in the localized string
155	*
156	* This is used for extracting the tag pattern groups for parsing the localized
157	* string and along with the map converting it to a react element.
158	*
159	* There are four references extracted using this tokenizer:
160	*
161	* match: Full match of the tag (i.e. <strong>, </strong>, <br/>)
162	* isClosing: The closing slash, if it exists.
163	* name: The name portion of the tag (strong, br) (if )
164	* isSelfClosed: The slash on a self closing tag, if it exists.
165	*
166	* @type {RegExp}
167	*/
168	const tokenizer = /<(\/)?(\w+)\s*(\/)?>/g;
169
170	/**
171	* The stack frame tracking parse progress.
172	*
173	* @typedef Frame
174	*
175	* @property {Element} element A parent element which may still have
176	* @property {number} tokenStart Offset at which parent element first
177	* appears.
178	* @property {number} tokenLength Length of string marking start of parent
179	* element.
180	* @property {number} [prevOffset] Running offset at which parsing should
181	* continue.
182	* @property {number} [leadingTextStart] Offset at which last closing element
183	* finished, used for finding text between
184	* elements.
185	* @property {Element[]} children Children.
186	*/
187
188	/**
189	* Tracks recursive-descent parse state.
190	*
191	* This is a Stack frame holding parent elements until all children have been
192	* parsed.
193	*
194	* @private
195	* @param {Element} element A parent element which may still have
196	* nested children not yet parsed.
197	* @param {number} tokenStart Offset at which parent element first
198	* appears.
199	* @param {number} tokenLength Length of string marking start of parent
200	* element.
201	* @param {number} [prevOffset] Running offset at which parsing should
202	* continue.
203	* @param {number} [leadingTextStart] Offset at which last closing element
204	* finished, used for finding text between
205	* elements.
206	*
207	* @return {Frame} The stack frame tracking parse progress.
208	*/
209	function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) {
210	return {
211	element,
212	tokenStart,
213	tokenLength,
214	prevOffset,
215	leadingTextStart,
216	children: []
217	};
218	}
219
220	/**
221	* This function creates an interpolated element from a passed in string with
222	* specific tags matching how the string should be converted to an element via
223	* the conversion map value.
224	*
225	* @example
226	* For example, for the given string:
227	*
228	* "This is a <span>string</span> with <a>a link</a> and a self-closing
229	* <CustomComponentB/> tag"
230	*
231	* You would have something like this as the conversionMap value:
232	*
233	* ```js
234	* {
235	* span: <span />,
236	* a: <a href={ 'https://github.com' } />,
237	* CustomComponentB: <CustomComponent />,
238	* }
239	* ```
240	*
241	* @param {string} interpolatedString The interpolation string to be parsed.
242	* @param {Record<string, Element>} conversionMap The map used to convert the string to
243	* a react element.
244	* @throws {TypeError}
245	* @return {Element} A wp element.
246	*/
247	const createInterpolateElement = (interpolatedString, conversionMap) => {
248	indoc = interpolatedString;
249	offset = 0;
250	output = [];
251	stack = [];
252	tokenizer.lastIndex = 0;
253	if (!isValidConversionMap(conversionMap)) {
254	throw new TypeError('The conversionMap provided is not valid. It must be an object with values that are React Elements');
255	}
256	do {
257	// twiddle our thumbs
258	} while (proceed(conversionMap));
259	return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, ...output);
260	};
261
262	/**
263	* Validate conversion map.
264	*
265	* A map is considered valid if it's an object and every value in the object
266	* is a React Element
267	*
268	* @private
269	*
270	* @param {Object} conversionMap The map being validated.
271	*
272	* @return {boolean} True means the map is valid.
273	*/
274	const isValidConversionMap = conversionMap => {
275	const isObject = typeof conversionMap === 'object';
276	const values = isObject && Object.values(conversionMap);
277	return isObject && values.length && values.every(element => (0,external_React_namespaceObject.isValidElement)(element));
278	};
279
280	/**
281	* This is the iterator over the matches in the string.
282	*
283	* @private
284	*
285	* @param {Object} conversionMap The conversion map for the string.
286	*
287	* @return {boolean} true for continuing to iterate, false for finished.
288	*/
289	function proceed(conversionMap) {
290	const next = nextToken();
291	const [tokenType, name, startOffset, tokenLength] = next;
292	const stackDepth = stack.length;
293	const leadingTextStart = startOffset > offset ? offset : null;
294	if (!conversionMap[name]) {
295	addText();
296	return false;
297	}
298	switch (tokenType) {
299	case 'no-more-tokens':
300	if (stackDepth !== 0) {
301	const {
302	leadingTextStart: stackLeadingText,
303	tokenStart
304	} = stack.pop();
305	output.push(indoc.substr(stackLeadingText, tokenStart));
306	}
307	addText();
308	return false;
309	case 'self-closed':
310	if (0 === stackDepth) {
311	if (null !== leadingTextStart) {
312	output.push(indoc.substr(leadingTextStart, startOffset - leadingTextStart));
313	}
314	output.push(conversionMap[name]);
315	offset = startOffset + tokenLength;
316	return true;
317	}
318
319	// Otherwise we found an inner element.
320	addChild(createFrame(conversionMap[name], startOffset, tokenLength));
321	offset = startOffset + tokenLength;
322	return true;
323	case 'opener':
324	stack.push(createFrame(conversionMap[name], startOffset, tokenLength, startOffset + tokenLength, leadingTextStart));
325	offset = startOffset + tokenLength;
326	return true;
327	case 'closer':
328	// If we're not nesting then this is easy - close the block.
329	if (1 === stackDepth) {
330	closeOuterElement(startOffset);
331	offset = startOffset + tokenLength;
332	return true;
333	}
334
335	// Otherwise we're nested and we have to close out the current
336	// block and add it as a innerBlock to the parent.
337	const stackTop = stack.pop();
338	const text = indoc.substr(stackTop.prevOffset, startOffset - stackTop.prevOffset);
339	stackTop.children.push(text);
340	stackTop.prevOffset = startOffset + tokenLength;
341	const frame = createFrame(stackTop.element, stackTop.tokenStart, stackTop.tokenLength, startOffset + tokenLength);
342	frame.children = stackTop.children;
343	addChild(frame);
344	offset = startOffset + tokenLength;
345	return true;
346	default:
347	addText();
348	return false;
349	}
350	}
351
352	/**
353	* Grabs the next token match in the string and returns it's details.
354	*
355	* @private
356	*
357	* @return {Array} An array of details for the token matched.
358	*/
359	function nextToken() {
360	const matches = tokenizer.exec(indoc);
361	// We have no more tokens.
362	if (null === matches) {
363	return ['no-more-tokens'];
364	}
365	const startedAt = matches.index;
366	const [match, isClosing, name, isSelfClosed] = matches;
367	const length = match.length;
368	if (isSelfClosed) {
369	return ['self-closed', name, startedAt, length];
370	}
371	if (isClosing) {
372	return ['closer', name, startedAt, length];
373	}
374	return ['opener', name, startedAt, length];
375	}
376
377	/**
378	* Pushes text extracted from the indoc string to the output stack given the
379	* current rawLength value and offset (if rawLength is provided ) or the
380	* indoc.length and offset.
381	*
382	* @private
383	*/
384	function addText() {
385	const length = indoc.length - offset;
386	if (0 === length) {
387	return;
388	}
389	output.push(indoc.substr(offset, length));
390	}
391
392	/**
393	* Pushes a child element to the associated parent element's children for the
394	* parent currently active in the stack.
395	*
396	* @private
397	*
398	* @param {Frame} frame The Frame containing the child element and it's
399	* token information.
400	*/
401	function addChild(frame) {
402	const {
403	element,
404	tokenStart,
405	tokenLength,
406	prevOffset,
407	children
408	} = frame;
409	const parent = stack[stack.length - 1];
410	const text = indoc.substr(parent.prevOffset, tokenStart - parent.prevOffset);
411	if (text) {
412	parent.children.push(text);
413	}
414	parent.children.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children));
415	parent.prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength;
416	}
417
418	/**
419	* This is called for closing tags. It creates the element currently active in
420	* the stack.
421	*
422	* @private
423	*
424	* @param {number} endOffset Offset at which the closing tag for the element
425	* begins in the string. If this is greater than the
426	* prevOffset attached to the element, then this
427	* helps capture any remaining nested text nodes in
428	* the element.
429	*/
430	function closeOuterElement(endOffset) {
431	const {
432	element,
433	leadingTextStart,
434	prevOffset,
435	tokenStart,
436	children
437	} = stack.pop();
438	const text = endOffset ? indoc.substr(prevOffset, endOffset - prevOffset) : indoc.substr(prevOffset);
439	if (text) {
440	children.push(text);
441	}
442	if (null !== leadingTextStart) {
443	output.push(indoc.substr(leadingTextStart, tokenStart - leadingTextStart));
444	}
445	output.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children));
446	}
447	/* harmony default export */ const create_interpolate_element = (createInterpolateElement);
448
449	;// CONCATENATED MODULE: ./packages/element/build-module/react.js
450	/**
451	* External dependencies
452	*/
453	// eslint-disable-next-line @typescript-eslint/no-restricted-imports
454
455
456	/**
457	* Object containing a React element.
458	*
459	* @typedef {import('react').ReactElement} Element
460	*/
461
462	/**
463	* Object containing a React component.
464	*
465	* @typedef {import('react').ComponentType} ComponentType
466	*/
467
468	/**
469	* Object containing a React synthetic event.
470	*
471	* @typedef {import('react').SyntheticEvent} SyntheticEvent
472	*/
473
474	/**
475	* Object containing a React synthetic event.
476	*
477	* @template T
478	* @typedef {import('react').RefObject<T>} RefObject<T>
479	*/
480
481	/**
482	* Object that provides utilities for dealing with React children.
483	*/
484
485
486	/**
487	* Creates a copy of an element with extended props.
488	*
489	* @param {Element} element Element
490	* @param {?Object} props Props to apply to cloned element
491	*
492	* @return {Element} Cloned element.
493	*/
494
495
496	/**
497	* A base class to create WordPress Components (Refs, state and lifecycle hooks)
498	*/
499
500
501	/**
502	* Creates a context object containing two components: a provider and consumer.
503	*
504	* @param {Object} defaultValue A default data stored in the context.
505	*
506	* @return {Object} Context object.
507	*/
508
509
510	/**
511	* Returns a new element of given type. Type can be either a string tag name or
512	* another function which itself returns an element.
513	*
514	* @param {?(string\|Function)} type Tag name or element creator
515	* @param {Object} props Element properties, either attribute
516	* set to apply to DOM node or values to
517	* pass through to element creator
518	* @param {...Element} children Descendant elements
519	*
520	* @return {Element} Element.
521	*/
522
523
524	/**
525	* Returns an object tracking a reference to a rendered element via its
526	* `current` property as either a DOMElement or Element, dependent upon the
527	* type of element rendered with the ref attribute.
528	*
529	* @return {Object} Ref object.
530	*/
531
532
533	/**
534	* Component enhancer used to enable passing a ref to its wrapped component.
535	* Pass a function argument which receives `props` and `ref` as its arguments,
536	* returning an element using the forwarded ref. The return value is a new
537	* component which forwards its ref.
538	*
539	* @param {Function} forwarder Function passed `props` and `ref`, expected to
540	* return an element.
541	*
542	* @return {Component} Enhanced component.
543	*/
544
545
546	/**
547	* A component which renders its children without any wrapping element.
548	*/
549
550
551	/**
552	* Checks if an object is a valid React Element.
553	*
554	* @param {Object} objectToCheck The object to be checked.
555	*
556	* @return {boolean} true if objectToTest is a valid React Element and false otherwise.
557	*/
558
559
560	/**
561	* @see https://react.dev/reference/react/memo
562	*/
563
564
565	/**
566	* Component that activates additional checks and warnings for its descendants.
567	*/
568
569
570	/**
571	* @see https://react.dev/reference/react/useCallback
572	*/
573
574
575	/**
576	* @see https://react.dev/reference/react/useContext
577	*/
578
579
580	/**
581	* @see https://react.dev/reference/react/useDebugValue
582	*/
583
584
585	/**
586	* @see https://react.dev/reference/react/useDeferredValue
587	*/
588
589
590	/**
591	* @see https://reactjs.org/docs/hooks-reference.html#useeffect
592	*/
593
594
595	/**
596	* @see https://react.dev/reference/react/useId
597	*/
598
599
600	/**
601	* @see https://react.dev/reference/react/useImperativeHandle
602	*/
603
604
605	/**
606	* @see https://react.dev/reference/react/useInsertionEffect
607	*/
608
609
610	/**
611	* @see https://react.dev/reference/react/useLayoutEffect
612	*/
613
614
615	/**
616	* @see https://react.dev/reference/react/useMemo
617	*/
618
619
620	/**
621	* @see https://react.dev/reference/react/useReducer
622	*/
623
624
625	/**
626	* @see https://react.dev/reference/react/useRef
627	*/
628
629
630	/**
631	* @see https://react.dev/reference/react/useState
632	*/
633
634
635	/**
636	* @see https://react.dev/reference/react/useSyncExternalStore
637	*/
638
639
640	/**
641	* @see https://react.dev/reference/react/useTransition
642	*/
643
644
645	/**
646	* @see https://react.dev/reference/react/startTransition
647	*/
648
649
650	/**
651	* @see https://react.dev/reference/react/lazy
652	*/
653
654
655	/**
656	* @see https://react.dev/reference/react/Suspense
657	*/
658
659
660	/**
661	* @see https://react.dev/reference/react/PureComponent
662	*/
663
664
665	/**
666	* Concatenate two or more React children objects.
667	*
668	* @param {...?Object} childrenArguments Array of children arguments (array of arrays/strings/objects) to concatenate.
669	*
670	* @return {Array} The concatenated value.
671	*/
672	function concatChildren(...childrenArguments) {
673	return childrenArguments.reduce((accumulator, children, i) => {
674	external_React_namespaceObject.Children.forEach(children, (child, j) => {
675	if (child && 'string' !== typeof child) {
676	child = (0,external_React_namespaceObject.cloneElement)(child, {
677	key: [i, j].join()
678	});
679	}
680	accumulator.push(child);
681	});
682	return accumulator;
683	}, []);
684	}
685
686	/**
687	* Switches the nodeName of all the elements in the children object.
688	*
689	* @param {?Object} children Children object.
690	* @param {string} nodeName Node name.
691	*
692	* @return {?Object} The updated children object.
693	*/
694	function switchChildrenNodeName(children, nodeName) {
695	return children && external_React_namespaceObject.Children.map(children, (elt, index) => {
696	if (typeof elt?.valueOf() === 'string') {
697	return (0,external_React_namespaceObject.createElement)(nodeName, {
698	key: index
699	}, elt);
700	}
701	const {
702	children: childrenProp,
703	...props
704	} = elt.props;
705	return (0,external_React_namespaceObject.createElement)(nodeName, {
706	key: index,
707	...props
708	}, childrenProp);
709	});
710	}
711
712	// EXTERNAL MODULE: external "ReactDOM"
713	var external_ReactDOM_ = __webpack_require__(1850);
714	// EXTERNAL MODULE: ./node_modules/react-dom/client.js
715	var client = __webpack_require__(4470);
716	;// CONCATENATED MODULE: ./packages/element/build-module/react-platform.js
717	/**
718	* External dependencies
719	*/
720
721
722
723	/**
724	* Creates a portal into which a component can be rendered.
725	*
726	* @see https://github.com/facebook/react/issues/10309#issuecomment-318433235
727	*
728	* @param {import('react').ReactElement} child Any renderable child, such as an element,
729	* string, or fragment.
730	* @param {HTMLElement} container DOM node into which element should be rendered.
731	*/
732
733
734	/**
735	* Finds the dom node of a React component.
736	*
737	* @param {import('react').ComponentType} component Component's instance.
738	*/
739
740
741	/**
742	* Forces React to flush any updates inside the provided callback synchronously.
743	*
744	* @param {Function} callback Callback to run synchronously.
745	*/
746
747
748	/**
749	* Renders a given element into the target DOM node.
750	*
751	* @deprecated since WordPress 6.2.0. Use `createRoot` instead.
752	* @see https://react.dev/reference/react-dom/render
753	*/
754
755
756	/**
757	* Hydrates a given element into the target DOM node.
758	*
759	* @deprecated since WordPress 6.2.0. Use `hydrateRoot` instead.
760	* @see https://react.dev/reference/react-dom/hydrate
761	*/
762
763
764	/**
765	* Creates a new React root for the target DOM node.
766	*
767	* @since 6.2.0 Introduced in WordPress core.
768	* @see https://react.dev/reference/react-dom/client/createRoot
769	*/
770
771
772	/**
773	* Creates a new React root for the target DOM node and hydrates it with a pre-generated markup.
774	*
775	* @since 6.2.0 Introduced in WordPress core.
776	* @see https://react.dev/reference/react-dom/client/hydrateRoot
777	*/
778
779
780	/**
781	* Removes any mounted element from the target DOM node.
782	*
783	* @deprecated since WordPress 6.2.0. Use `root.unmount()` instead.
784	* @see https://react.dev/reference/react-dom/unmountComponentAtNode
785	*/
786
787
788	;// CONCATENATED MODULE: ./packages/element/build-module/utils.js
789	/**
790	* Checks if the provided WP element is empty.
791	*
792	* @param {*} element WP element to check.
793	* @return {boolean} True when an element is considered empty.
794	*/
795	const isEmptyElement = element => {
796	if (typeof element === 'number') {
797	return false;
798	}
799	if (typeof element?.valueOf() === 'string' \|\| Array.isArray(element)) {
800	return !element.length;
801	}
802	return !element;
803	};
804
805	;// CONCATENATED MODULE: ./packages/element/build-module/platform.js
806	/**
807	* Parts of this source were derived and modified from react-native-web,
808	* released under the MIT license.
809	*
810	* Copyright (c) 2016-present, Nicolas Gallagher.
811	* Copyright (c) 2015-present, Facebook, Inc.
812	*
813	*/
814	const Platform = {
815	OS: 'web',
816	select: spec => 'web' in spec ? spec.web : spec.default,
817	isWeb: true
818	};
819	/**
820	* Component used to detect the current Platform being used.
821	* Use Platform.OS === 'web' to detect if running on web enviroment.
822	*
823	* This is the same concept as the React Native implementation.
824	*
825	* @see https://reactnative.dev/docs/platform-specific-code#platform-module
826	*
827	* Here is an example of how to use the select method:
828	* @example
829	* ```js
830	* import { Platform } from '@wordpress/element';
831	*
832	* const placeholderLabel = Platform.select( {
833	* native: __( 'Add media' ),
834	* web: __( 'Drag images, upload new ones or select files from your library.' ),
835	* } );
836	* ```
837	*/
838	/* harmony default export */ const platform = (Platform);
839
840	;// CONCATENATED MODULE: ./node_modules/is-plain-object/dist/is-plain-object.mjs
841	/*!
842	* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
843	*
844	* Copyright (c) 2014-2017, Jon Schlinkert.
845	* Released under the MIT License.
846	*/
847
848	function isObject(o) {
849	return Object.prototype.toString.call(o) === '[object Object]';
850	}
851
852	function isPlainObject(o) {
853	var ctor,prot;
854
855	if (isObject(o) === false) return false;
856
857	// If has modified constructor
858	ctor = o.constructor;
859	if (ctor === undefined) return true;
860
861	// If has modified prototype
862	prot = ctor.prototype;
863	if (isObject(prot) === false) return false;
864
865	// If constructor does not have an Object-specific method
866	if (prot.hasOwnProperty('isPrototypeOf') === false) {
867	return false;
868	}
869
870	// Most likely a plain Object
871	return true;
872	}
873
874
875
876	;// CONCATENATED MODULE: ./node_modules/tslib/tslib.es6.mjs
877	/******************************************************************************
878	Copyright (c) Microsoft Corporation.
879
880	Permission to use, copy, modify, and/or distribute this software for any
881	purpose with or without fee is hereby granted.
882
883	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
884	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
885	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
886	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
887	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
888	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
889	PERFORMANCE OF THIS SOFTWARE.
890	***************************************************************************** */
891	/* global Reflect, Promise, SuppressedError, Symbol */
892
893	var extendStatics = function(d, b) {
894	extendStatics = Object.setPrototypeOf \|\|
895	({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
896	function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
897	return extendStatics(d, b);
898	};
899
900	function __extends(d, b) {
901	if (typeof b !== "function" && b !== null)
902	throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
903	extendStatics(d, b);
904	function __() { this.constructor = d; }
905	d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
906	}
907
908	var __assign = function() {
909	__assign = Object.assign \|\| function __assign(t) {
910	for (var s, i = 1, n = arguments.length; i < n; i++) {
911	s = arguments[i];
912	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
913	}
914	return t;
915	}
916	return __assign.apply(this, arguments);
917	}
918
919	function __rest(s, e) {
920	var t = {};
921	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
922	t[p] = s[p];
923	if (s != null && typeof Object.getOwnPropertySymbols === "function")
924	for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
925	if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
926	t[p[i]] = s[p[i]];
927	}
928	return t;
929	}
930
931	function __decorate(decorators, target, key, desc) {
932	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
933	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
934	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) \|\| r;
935	return c > 3 && r && Object.defineProperty(target, key, r), r;
936	}
937
938	function __param(paramIndex, decorator) {
939	return function (target, key) { decorator(target, key, paramIndex); }
940	}
941
942	function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
943	function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
944	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
945	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
946	var descriptor = descriptorIn \|\| (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
947	var _, done = false;
948	for (var i = decorators.length - 1; i >= 0; i--) {
949	var context = {};
950	for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
951	for (var p in contextIn.access) context.access[p] = contextIn.access[p];
952	context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f \|\| null)); };
953	var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
954	if (kind === "accessor") {
955	if (result === void 0) continue;
956	if (result === null \|\| typeof result !== "object") throw new TypeError("Object expected");
957	if (_ = accept(result.get)) descriptor.get = _;
958	if (_ = accept(result.set)) descriptor.set = _;
959	if (_ = accept(result.init)) initializers.unshift(_);
960	}
961	else if (_ = accept(result)) {
962	if (kind === "field") initializers.unshift(_);
963	else descriptor[key] = _;
964	}
965	}
966	if (target) Object.defineProperty(target, contextIn.name, descriptor);
967	done = true;
968	};
969
970	function __runInitializers(thisArg, initializers, value) {
971	var useValue = arguments.length > 2;
972	for (var i = 0; i < initializers.length; i++) {
973	value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
974	}
975	return useValue ? value : void 0;
976	};
977
978	function __propKey(x) {
979	return typeof x === "symbol" ? x : "".concat(x);
980	};
981
982	function __setFunctionName(f, name, prefix) {
983	if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
984	return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
985	};
986
987	function __metadata(metadataKey, metadataValue) {
988	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
989	}
990
991	function __awaiter(thisArg, _arguments, P, generator) {
992	function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
993	return new (P \|\| (P = Promise))(function (resolve, reject) {
994	function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
995	function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
996	function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
997	step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
998	});
999	}
1000
1001	function __generator(thisArg, body) {
1002	var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
1003	return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
1004	function verb(n) { return function (v) { return step([n, v]); }; }
1005	function step(op) {
1006	if (f) throw new TypeError("Generator is already executing.");
1007	while (g && (g = 0, op[0] && (_ = 0)), _) try {
1008	if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] \|\| ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
1009	if (y = 0, t) op = [op[0] & 2, t.value];
1010	switch (op[0]) {
1011	case 0: case 1: t = op; break;
1012	case 4: _.label++; return { value: op[1], done: false };
1013	case 5: _.label++; y = op[1]; op = [0]; continue;
1014	case 7: op = _.ops.pop(); _.trys.pop(); continue;
1015	default:
1016	if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 \|\| op[0] === 2)) { _ = 0; continue; }
1017	if (op[0] === 3 && (!t \|\| (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
1018	if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
1019	if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
1020	if (t[2]) _.ops.pop();
1021	_.trys.pop(); continue;
1022	}
1023	op = body.call(thisArg, _);
1024	} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
1025	if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
1026	}
1027	}
1028
1029	var __createBinding = Object.create ? (function(o, m, k, k2) {
1030	if (k2 === undefined) k2 = k;
1031	var desc = Object.getOwnPropertyDescriptor(m, k);
1032	if (!desc \|\| ("get" in desc ? !m.__esModule : desc.writable \|\| desc.configurable)) {
1033	desc = { enumerable: true, get: function() { return m[k]; } };
1034	}
1035	Object.defineProperty(o, k2, desc);
1036	}) : (function(o, m, k, k2) {
1037	if (k2 === undefined) k2 = k;
1038	o[k2] = m[k];
1039	});
1040
1041	function __exportStar(m, o) {
1042	for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
1043	}
1044
1045	function __values(o) {
1046	var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
1047	if (m) return m.call(o);
1048	if (o && typeof o.length === "number") return {
1049	next: function () {
1050	if (o && i >= o.length) o = void 0;
1051	return { value: o && o[i++], done: !o };
1052	}
1053	};
1054	throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
1055	}
1056
1057	function __read(o, n) {
1058	var m = typeof Symbol === "function" && o[Symbol.iterator];
1059	if (!m) return o;
1060	var i = m.call(o), r, ar = [], e;
1061	try {
1062	while ((n === void 0 \|\| n-- > 0) && !(r = i.next()).done) ar.push(r.value);
1063	}
1064	catch (error) { e = { error: error }; }
1065	finally {
1066	try {
1067	if (r && !r.done && (m = i["return"])) m.call(i);
1068	}
1069	finally { if (e) throw e.error; }
1070	}
1071	return ar;
1072	}
1073
1074	/** @deprecated */
1075	function __spread() {
1076	for (var ar = [], i = 0; i < arguments.length; i++)
1077	ar = ar.concat(__read(arguments[i]));
1078	return ar;
1079	}
1080
1081	/** @deprecated */
1082	function __spreadArrays() {
1083	for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
1084	for (var r = Array(s), k = 0, i = 0; i < il; i++)
1085	for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
1086	r[k] = a[j];
1087	return r;
1088	}
1089
1090	function __spreadArray(to, from, pack) {
1091	if (pack \|\| arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
1092	if (ar \|\| !(i in from)) {
1093	if (!ar) ar = Array.prototype.slice.call(from, 0, i);
1094	ar[i] = from[i];
1095	}
1096	}
1097	return to.concat(ar \|\| Array.prototype.slice.call(from));
1098	}
1099
1100	function __await(v) {
1101	return this instanceof __await ? (this.v = v, this) : new __await(v);
1102	}
1103
1104	function __asyncGenerator(thisArg, _arguments, generator) {
1105	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
1106	var g = generator.apply(thisArg, _arguments \|\| []), i, q = [];
1107	return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
1108	function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 \|\| resume(n, v); }); }; }
1109	function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
1110	function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
1111	function fulfill(value) { resume("next", value); }
1112	function reject(value) { resume("throw", value); }
1113	function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
1114	}
1115
1116	function __asyncDelegator(o) {
1117	var i, p;
1118	return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
1119	function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
1120	}
1121
1122	function __asyncValues(o) {
1123	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
1124	var m = o[Symbol.asyncIterator], i;
1125	return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
1126	function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
1127	function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
1128	}
1129
1130	function __makeTemplateObject(cooked, raw) {
1131	if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
1132	return cooked;
1133	};
1134
1135	var __setModuleDefault = Object.create ? (function(o, v) {
1136	Object.defineProperty(o, "default", { enumerable: true, value: v });
1137	}) : function(o, v) {
1138	o["default"] = v;
1139	};
1140
1141	function __importStar(mod) {
1142	if (mod && mod.__esModule) return mod;
1143	var result = {};
1144	if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
1145	__setModuleDefault(result, mod);
1146	return result;
1147	}
1148
1149	function __importDefault(mod) {
1150	return (mod && mod.__esModule) ? mod : { default: mod };
1151	}
1152
1153	function __classPrivateFieldGet(receiver, state, kind, f) {
1154	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
1155	if (typeof state === "function" ? receiver !== state \|\| !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
1156	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
1157	}
1158
1159	function __classPrivateFieldSet(receiver, state, value, kind, f) {
1160	if (kind === "m") throw new TypeError("Private method is not writable");
1161	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
1162	if (typeof state === "function" ? receiver !== state \|\| !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
1163	return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
1164	}
1165
1166	function __classPrivateFieldIn(state, receiver) {
1167	if (receiver === null \|\| (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
1168	return typeof state === "function" ? receiver === state : state.has(receiver);
1169	}
1170
1171	function __addDisposableResource(env, value, async) {
1172	if (value !== null && value !== void 0) {
1173	if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
1174	var dispose;
1175	if (async) {
1176	if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
1177	dispose = value[Symbol.asyncDispose];
1178	}
1179	if (dispose === void 0) {
1180	if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
1181	dispose = value[Symbol.dispose];
1182	}
1183	if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
1184	env.stack.push({ value: value, dispose: dispose, async: async });
1185	}
1186	else if (async) {
1187	env.stack.push({ async: true });
1188	}
1189	return value;
1190	}
1191
1192	var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
1193	var e = new Error(message);
1194	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
1195	};
1196
1197	function __disposeResources(env) {
1198	function fail(e) {
1199	env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
1200	env.hasError = true;
1201	}
1202	function next() {
1203	while (env.stack.length) {
1204	var rec = env.stack.pop();
1205	try {
1206	var result = rec.dispose && rec.dispose.call(rec.value);
1207	if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
1208	}
1209	catch (e) {
1210	fail(e);
1211	}
1212	}
1213	if (env.hasError) throw env.error;
1214	}
1215	return next();
1216	}
1217
1218	/* harmony default export */ const tslib_es6 = ({
1219	__extends,
1220	__assign,
1221	__rest,
1222	__decorate,
1223	__param,
1224	__metadata,
1225	__awaiter,
1226	__generator,
1227	__createBinding,
1228	__exportStar,
1229	__values,
1230	__read,
1231	__spread,
1232	__spreadArrays,
1233	__spreadArray,
1234	__await,
1235	__asyncGenerator,
1236	__asyncDelegator,
1237	__asyncValues,
1238	__makeTemplateObject,
1239	__importStar,
1240	__importDefault,
1241	__classPrivateFieldGet,
1242	__classPrivateFieldSet,
1243	__classPrivateFieldIn,
1244	__addDisposableResource,
1245	__disposeResources,
1246	});
1247
1248	;// CONCATENATED MODULE: ./node_modules/lower-case/dist.es2015/index.js
1249	/**
1250	* Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
1251	*/
1252	var SUPPORTED_LOCALE = {
1253	tr: {
1254	regexp: /\u0130\|\u0049\|\u0049\u0307/g,
1255	map: {
1256	İ: "\u0069",
1257	I: "\u0131",
1258	İ: "\u0069",
1259	},
1260	},
1261	az: {
1262	regexp: /\u0130/g,
1263	map: {
1264	İ: "\u0069",
1265	I: "\u0131",
1266	İ: "\u0069",
1267	},
1268	},
1269	lt: {
1270	regexp: /\u0049\|\u004A\|\u012E\|\u00CC\|\u00CD\|\u0128/g,
1271	map: {
1272	I: "\u0069\u0307",
1273	J: "\u006A\u0307",
1274	Į: "\u012F\u0307",
1275	Ì: "\u0069\u0307\u0300",
1276	Í: "\u0069\u0307\u0301",
1277	Ĩ: "\u0069\u0307\u0303",
1278	},
1279	},
1280	};
1281	/**
1282	* Localized lower case.
1283	*/
1284	function localeLowerCase(str, locale) {
1285	var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
1286	if (lang)
1287	return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
1288	return lowerCase(str);
1289	}
1290	/**
1291	* Lower case as a function.
1292	*/
1293	function lowerCase(str) {
1294	return str.toLowerCase();
1295	}
1296
1297	;// CONCATENATED MODULE: ./node_modules/no-case/dist.es2015/index.js
1298
1299	// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
1300	var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
1301	// Remove all non-word characters.
1302	var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
1303	/**
1304	* Normalize the string into something other libraries can manipulate easier.
1305	*/
1306	function noCase(input, options) {
1307	if (options === void 0) { options = {}; }
1308	var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
1309	var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
1310	var start = 0;
1311	var end = result.length;
1312	// Trim the delimiter from around the output string.
1313	while (result.charAt(start) === "\0")
1314	start++;
1315	while (result.charAt(end - 1) === "\0")
1316	end--;
1317	// Transform each token independently.
1318	return result.slice(start, end).split("\0").map(transform).join(delimiter);
1319	}
1320	/**
1321	* Replace `re` in the input string with the replacement value.
1322	*/
1323	function replace(input, re, value) {
1324	if (re instanceof RegExp)
1325	return input.replace(re, value);
1326	return re.reduce(function (input, re) { return input.replace(re, value); }, input);
1327	}
1328
1329	;// CONCATENATED MODULE: ./node_modules/dot-case/dist.es2015/index.js
1330
1331
1332	function dotCase(input, options) {
1333	if (options === void 0) { options = {}; }
1334	return noCase(input, __assign({ delimiter: "." }, options));
1335	}
1336
1337	;// CONCATENATED MODULE: ./node_modules/param-case/dist.es2015/index.js
1338
1339
1340	function paramCase(input, options) {
1341	if (options === void 0) { options = {}; }
1342	return dotCase(input, __assign({ delimiter: "-" }, options));
1343	}
1344
1345	;// CONCATENATED MODULE: external ["wp","escapeHtml"]
1346	const external_wp_escapeHtml_namespaceObject = window["wp"]["escapeHtml"];
1347	;// CONCATENATED MODULE: ./packages/element/build-module/raw-html.js
1348	/**
1349	* Internal dependencies
1350	*/
1351
1352
1353	/** @typedef {{children: string} & import('react').ComponentPropsWithoutRef<'div'>} RawHTMLProps */
1354
1355	/**
1356	* Component used as equivalent of Fragment with unescaped HTML, in cases where
1357	* it is desirable to render dangerous HTML without needing a wrapper element.
1358	* To preserve additional props, a `div` wrapper _will_ be created if any props
1359	* aside from `children` are passed.
1360	*
1361	* @param {RawHTMLProps} props Children should be a string of HTML or an array
1362	* of strings. Other props will be passed through
1363	* to the div wrapper.
1364	*
1365	* @return {JSX.Element} Dangerously-rendering component.
1366	*/
1367	function RawHTML({
1368	children,
1369	...props
1370	}) {
1371	let rawHtml = '';
1372
1373	// Cast children as an array, and concatenate each element if it is a string.
1374	external_React_namespaceObject.Children.toArray(children).forEach(child => {
1375	if (typeof child === 'string' && child.trim() !== '') {
1376	rawHtml += child;
1377	}
1378	});
1379
1380	// The `div` wrapper will be stripped by the `renderElement` serializer in
1381	// `./serialize.js` unless there are non-children props present.
1382	return (0,external_React_namespaceObject.createElement)('div', {
1383	dangerouslySetInnerHTML: {
1384	__html: rawHtml
1385	},
1386	...props
1387	});
1388	}
1389
1390	;// CONCATENATED MODULE: ./packages/element/build-module/serialize.js
1391	/**
1392	* Parts of this source were derived and modified from fast-react-render,
1393	* released under the MIT license.
1394	*
1395	* https://github.com/alt-j/fast-react-render
1396	*
1397	* Copyright (c) 2016 Andrey Morozov
1398	*
1399	* Permission is hereby granted, free of charge, to any person obtaining a copy
1400	* of this software and associated documentation files (the "Software"), to deal
1401	* in the Software without restriction, including without limitation the rights
1402	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
1403	* copies of the Software, and to permit persons to whom the Software is
1404	* furnished to do so, subject to the following conditions:
1405	*
1406	* The above copyright notice and this permission notice shall be included in
1407	* all copies or substantial portions of the Software.
1408	*
1409	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1410	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1411	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1412	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1413	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
1414	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
1415	* THE SOFTWARE.
1416	*/
1417
1418	/**
1419	* External dependencies
1420	*/
1421
1422
1423
1424	/**
1425	* WordPress dependencies
1426	*/
1427
1428
1429	/**
1430	* Internal dependencies
1431	*/
1432
1433
1434
1435	/** @typedef {import('react').ReactElement} ReactElement */
1436
1437	const {
1438	Provider,
1439	Consumer
1440	} = (0,external_React_namespaceObject.createContext)(undefined);
1441	const ForwardRef = (0,external_React_namespaceObject.forwardRef)(() => {
1442	return null;
1443	});
1444
1445	/**
1446	* Valid attribute types.
1447	*
1448	* @type {Set<string>}
1449	*/
1450	const ATTRIBUTES_TYPES = new Set(['string', 'boolean', 'number']);
1451
1452	/**
1453	* Element tags which can be self-closing.
1454	*
1455	* @type {Set<string>}
1456	*/
1457	const SELF_CLOSING_TAGS = new Set(['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
1458
1459	/**
1460	* Boolean attributes are attributes whose presence as being assigned is
1461	* meaningful, even if only empty.
1462	*
1463	* See: https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
1464	* Extracted from: https://html.spec.whatwg.org/multipage/indices.html#attributes-3
1465	*
1466	* Object.keys( [ ...document.querySelectorAll( '#attributes-1 > tbody > tr' ) ]
1467	* .filter( ( tr ) => tr.lastChild.textContent.indexOf( 'Boolean attribute' ) !== -1 )
1468	* .reduce( ( result, tr ) => Object.assign( result, {
1469	* [ tr.firstChild.textContent.trim() ]: true
1470	* } ), {} ) ).sort();
1471	*
1472	* @type {Set<string>}
1473	*/
1474	const BOOLEAN_ATTRIBUTES = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowusermedia', 'async', 'autofocus', 'autoplay', 'checked', 'controls', 'default', 'defer', 'disabled', 'download', 'formnovalidate', 'hidden', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nomodule', 'novalidate', 'open', 'playsinline', 'readonly', 'required', 'reversed', 'selected', 'typemustmatch']);
1475
1476	/**
1477	* Enumerated attributes are attributes which must be of a specific value form.
1478	* Like boolean attributes, these are meaningful if specified, even if not of a
1479	* valid enumerated value.
1480	*
1481	* See: https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#enumerated-attribute
1482	* Extracted from: https://html.spec.whatwg.org/multipage/indices.html#attributes-3
1483	*
1484	* Object.keys( [ ...document.querySelectorAll( '#attributes-1 > tbody > tr' ) ]
1485	* .filter( ( tr ) => /^("(.+?)";?\s*)+/.test( tr.lastChild.textContent.trim() ) )
1486	* .reduce( ( result, tr ) => Object.assign( result, {
1487	* [ tr.firstChild.textContent.trim() ]: true
1488	* } ), {} ) ).sort();
1489	*
1490	* Some notable omissions:
1491	*
1492	* - `alt`: https://blog.whatwg.org/omit-alt
1493	*
1494	* @type {Set<string>}
1495	*/
1496	const ENUMERATED_ATTRIBUTES = new Set(['autocapitalize', 'autocomplete', 'charset', 'contenteditable', 'crossorigin', 'decoding', 'dir', 'draggable', 'enctype', 'formenctype', 'formmethod', 'http-equiv', 'inputmode', 'kind', 'method', 'preload', 'scope', 'shape', 'spellcheck', 'translate', 'type', 'wrap']);
1497
1498	/**
1499	* Set of CSS style properties which support assignment of unitless numbers.
1500	* Used in rendering of style properties, where `px` unit is assumed unless
1501	* property is included in this set or value is zero.
1502	*
1503	* Generated via:
1504	*
1505	* Object.entries( document.createElement( 'div' ).style )
1506	* .filter( ( [ key ] ) => (
1507	* ! /^(webkit\|ms\|moz)/.test( key ) &&
1508	* ( e.style[ key ] = 10 ) &&
1509	* e.style[ key ] === '10'
1510	* ) )
1511	* .map( ( [ key ] ) => key )
1512	* .sort();
1513	*
1514	* @type {Set<string>}
1515	*/
1516	const CSS_PROPERTIES_SUPPORTS_UNITLESS = new Set(['animation', 'animationIterationCount', 'baselineShift', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'columnCount', 'cx', 'cy', 'fillOpacity', 'flexGrow', 'flexShrink', 'floodOpacity', 'fontWeight', 'gridColumnEnd', 'gridColumnStart', 'gridRowEnd', 'gridRowStart', 'lineHeight', 'opacity', 'order', 'orphans', 'r', 'rx', 'ry', 'shapeImageThreshold', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'tabSize', 'widows', 'x', 'y', 'zIndex', 'zoom']);
1517
1518	/**
1519	* Returns true if the specified string is prefixed by one of an array of
1520	* possible prefixes.
1521	*
1522	* @param {string} string String to check.
1523	* @param {string[]} prefixes Possible prefixes.
1524	*
1525	* @return {boolean} Whether string has prefix.
1526	*/
1527	function hasPrefix(string, prefixes) {
1528	return prefixes.some(prefix => string.indexOf(prefix) === 0);
1529	}
1530
1531	/**
1532	* Returns true if the given prop name should be ignored in attributes
1533	* serialization, or false otherwise.
1534	*
1535	* @param {string} attribute Attribute to check.
1536	*
1537	* @return {boolean} Whether attribute should be ignored.
1538	*/
1539	function isInternalAttribute(attribute) {
1540	return 'key' === attribute \|\| 'children' === attribute;
1541	}
1542
1543	/**
1544	* Returns the normal form of the element's attribute value for HTML.
1545	*
1546	* @param {string} attribute Attribute name.
1547	* @param {*} value Non-normalized attribute value.
1548	*
1549	* @return {*} Normalized attribute value.
1550	*/
1551	function getNormalAttributeValue(attribute, value) {
1552	switch (attribute) {
1553	case 'style':
1554	return renderStyle(value);
1555	}
1556	return value;
1557	}
1558	/**
1559	* This is a map of all SVG attributes that have dashes. Map(lower case prop => dashed lower case attribute).
1560	* We need this to render e.g strokeWidth as stroke-width.
1561	*
1562	* List from: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute.
1563	*/
1564	const SVG_ATTRIBUTE_WITH_DASHES_LIST = ['accentHeight', 'alignmentBaseline', 'arabicForm', 'baselineShift', 'capHeight', 'clipPath', 'clipRule', 'colorInterpolation', 'colorInterpolationFilters', 'colorProfile', 'colorRendering', 'dominantBaseline', 'enableBackground', 'fillOpacity', 'fillRule', 'floodColor', 'floodOpacity', 'fontFamily', 'fontSize', 'fontSizeAdjust', 'fontStretch', 'fontStyle', 'fontVariant', 'fontWeight', 'glyphName', 'glyphOrientationHorizontal', 'glyphOrientationVertical', 'horizAdvX', 'horizOriginX', 'imageRendering', 'letterSpacing', 'lightingColor', 'markerEnd', 'markerMid', 'markerStart', 'overlinePosition', 'overlineThickness', 'paintOrder', 'panose1', 'pointerEvents', 'renderingIntent', 'shapeRendering', 'stopColor', 'stopOpacity', 'strikethroughPosition', 'strikethroughThickness', 'strokeDasharray', 'strokeDashoffset', 'strokeLinecap', 'strokeLinejoin', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'textAnchor', 'textDecoration', 'textRendering', 'underlinePosition', 'underlineThickness', 'unicodeBidi', 'unicodeRange', 'unitsPerEm', 'vAlphabetic', 'vHanging', 'vIdeographic', 'vMathematical', 'vectorEffect', 'vertAdvY', 'vertOriginX', 'vertOriginY', 'wordSpacing', 'writingMode', 'xmlnsXlink', 'xHeight'].reduce((map, attribute) => {
1565	// The keys are lower-cased for more robust lookup.
1566	map[attribute.toLowerCase()] = attribute;
1567	return map;
1568	}, {});
1569
1570	/**
1571	* This is a map of all case-sensitive SVG attributes. Map(lowercase key => proper case attribute).
1572	* The keys are lower-cased for more robust lookup.
1573	* Note that this list only contains attributes that contain at least one capital letter.
1574	* Lowercase attributes don't need mapping, since we lowercase all attributes by default.
1575	*/
1576	const CASE_SENSITIVE_SVG_ATTRIBUTES = ['allowReorder', 'attributeName', 'attributeType', 'autoReverse', 'baseFrequency', 'baseProfile', 'calcMode', 'clipPathUnits', 'contentScriptType', 'contentStyleType', 'diffuseConstant', 'edgeMode', 'externalResourcesRequired', 'filterRes', 'filterUnits', 'glyphRef', 'gradientTransform', 'gradientUnits', 'kernelMatrix', 'kernelUnitLength', 'keyPoints', 'keySplines', 'keyTimes', 'lengthAdjust', 'limitingConeAngle', 'markerHeight', 'markerUnits', 'markerWidth', 'maskContentUnits', 'maskUnits', 'numOctaves', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'refX', 'refY', 'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures', 'specularConstant', 'specularExponent', 'spreadMethod', 'startOffset', 'stdDeviation', 'stitchTiles', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textLength', 'viewBox', 'viewTarget', 'xChannelSelector', 'yChannelSelector'].reduce((map, attribute) => {
1577	// The keys are lower-cased for more robust lookup.
1578	map[attribute.toLowerCase()] = attribute;
1579	return map;
1580	}, {});
1581
1582	/**
1583	* This is a map of all SVG attributes that have colons.
1584	* Keys are lower-cased and stripped of their colons for more robust lookup.
1585	*/
1586	const SVG_ATTRIBUTES_WITH_COLONS = ['xlink:actuate', 'xlink:arcrole', 'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type', 'xml:base', 'xml:lang', 'xml:space', 'xmlns:xlink'].reduce((map, attribute) => {
1587	map[attribute.replace(':', '').toLowerCase()] = attribute;
1588	return map;
1589	}, {});
1590
1591	/**
1592	* Returns the normal form of the element's attribute name for HTML.
1593	*
1594	* @param {string} attribute Non-normalized attribute name.
1595	*
1596	* @return {string} Normalized attribute name.
1597	*/
1598	function getNormalAttributeName(attribute) {
1599	switch (attribute) {
1600	case 'htmlFor':
1601	return 'for';
1602	case 'className':
1603	return 'class';
1604	}
1605	const attributeLowerCase = attribute.toLowerCase();
1606	if (CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]) {
1607	return CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase];
1608	} else if (SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]) {
1609	return paramCase(SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]);
1610	} else if (SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]) {
1611	return SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase];
1612	}
1613	return attributeLowerCase;
1614	}
1615
1616	/**
1617	* Returns the normal form of the style property name for HTML.
1618	*
1619	* - Converts property names to kebab-case, e.g. 'backgroundColor' → 'background-color'
1620	* - Leaves custom attributes alone, e.g. '--myBackgroundColor' → '--myBackgroundColor'
1621	* - Converts vendor-prefixed property names to -kebab-case, e.g. 'MozTransform' → '-moz-transform'
1622	*
1623	* @param {string} property Property name.
1624	*
1625	* @return {string} Normalized property name.
1626	*/
1627	function getNormalStylePropertyName(property) {
1628	if (property.startsWith('--')) {
1629	return property;
1630	}
1631	if (hasPrefix(property, ['ms', 'O', 'Moz', 'Webkit'])) {
1632	return '-' + paramCase(property);
1633	}
1634	return paramCase(property);
1635	}
1636
1637	/**
1638	* Returns the normal form of the style property value for HTML. Appends a
1639	* default pixel unit if numeric, not a unitless property, and not zero.
1640	*
1641	* @param {string} property Property name.
1642	* @param {*} value Non-normalized property value.
1643	*
1644	* @return {*} Normalized property value.
1645	*/
1646	function getNormalStylePropertyValue(property, value) {
1647	if (typeof value === 'number' && 0 !== value && !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) {
1648	return value + 'px';
1649	}
1650	return value;
1651	}
1652
1653	/**
1654	* Serializes a React element to string.
1655	*
1656	* @param {import('react').ReactNode} element Element to serialize.
1657	* @param {Object} [context] Context object.
1658	* @param {Object} [legacyContext] Legacy context object.
1659	*
1660	* @return {string} Serialized element.
1661	*/
1662	function renderElement(element, context, legacyContext = {}) {
1663	if (null === element \|\| undefined === element \|\| false === element) {
1664	return '';
1665	}
1666	if (Array.isArray(element)) {
1667	return renderChildren(element, context, legacyContext);
1668	}
1669	switch (typeof element) {
1670	case 'string':
1671	return (0,external_wp_escapeHtml_namespaceObject.escapeHTML)(element);
1672	case 'number':
1673	return element.toString();
1674	}
1675	const {
1676	type,
1677	props
1678	} = /** @type {{type?: any, props?: any}} */
1679	element;
1680	switch (type) {
1681	case external_React_namespaceObject.StrictMode:
1682	case external_React_namespaceObject.Fragment:
1683	return renderChildren(props.children, context, legacyContext);
1684	case RawHTML:
1685	const {
1686	children,
1687	...wrapperProps
1688	} = props;
1689	return renderNativeComponent(!Object.keys(wrapperProps).length ? null : 'div', {
1690	...wrapperProps,
1691	dangerouslySetInnerHTML: {
1692	__html: children
1693	}
1694	}, context, legacyContext);
1695	}
1696	switch (typeof type) {
1697	case 'string':
1698	return renderNativeComponent(type, props, context, legacyContext);
1699	case 'function':
1700	if (type.prototype && typeof type.prototype.render === 'function') {
1701	return renderComponent(type, props, context, legacyContext);
1702	}
1703	return renderElement(type(props, legacyContext), context, legacyContext);
1704	}
1705	switch (type && type.$$typeof) {
1706	case Provider.$$typeof:
1707	return renderChildren(props.children, props.value, legacyContext);
1708	case Consumer.$$typeof:
1709	return renderElement(props.children(context \|\| type._currentValue), context, legacyContext);
1710	case ForwardRef.$$typeof:
1711	return renderElement(type.render(props), context, legacyContext);
1712	}
1713	return '';
1714	}
1715
1716	/**
1717	* Serializes a native component type to string.
1718	*
1719	* @param {?string} type Native component type to serialize, or null if
1720	* rendering as fragment of children content.
1721	* @param {Object} props Props object.
1722	* @param {Object} [context] Context object.
1723	* @param {Object} [legacyContext] Legacy context object.
1724	*
1725	* @return {string} Serialized element.
1726	*/
1727	function renderNativeComponent(type, props, context, legacyContext = {}) {
1728	let content = '';
1729	if (type === 'textarea' && props.hasOwnProperty('value')) {
1730	// Textarea children can be assigned as value prop. If it is, render in
1731	// place of children. Ensure to omit so it is not assigned as attribute
1732	// as well.
1733	content = renderChildren(props.value, context, legacyContext);
1734	const {
1735	value,
1736	...restProps
1737	} = props;
1738	props = restProps;
1739	} else if (props.dangerouslySetInnerHTML && typeof props.dangerouslySetInnerHTML.__html === 'string') {
1740	// Dangerous content is left unescaped.
1741	content = props.dangerouslySetInnerHTML.__html;
1742	} else if (typeof props.children !== 'undefined') {
1743	content = renderChildren(props.children, context, legacyContext);
1744	}
1745	if (!type) {
1746	return content;
1747	}
1748	const attributes = renderAttributes(props);
1749	if (SELF_CLOSING_TAGS.has(type)) {
1750	return '<' + type + attributes + '/>';
1751	}
1752	return '<' + type + attributes + '>' + content + '</' + type + '>';
1753	}
1754
1755	/** @typedef {import('react').ComponentType} ComponentType */
1756
1757	/**
1758	* Serializes a non-native component type to string.
1759	*
1760	* @param {ComponentType} Component Component type to serialize.
1761	* @param {Object} props Props object.
1762	* @param {Object} [context] Context object.
1763	* @param {Object} [legacyContext] Legacy context object.
1764	*
1765	* @return {string} Serialized element
1766	*/
1767	function renderComponent(Component, props, context, legacyContext = {}) {
1768	const instance = new ( /** @type {import('react').ComponentClass} */
1769	Component)(props, legacyContext);
1770	if (typeof
1771	// Ignore reason: Current prettier reformats parens and mangles type assertion
1772	// prettier-ignore
1773	/** @type {{getChildContext?: () => unknown}} */
1774	instance.getChildContext === 'function') {
1775	Object.assign(legacyContext, /** @type {{getChildContext?: () => unknown}} */instance.getChildContext());
1776	}
1777	const html = renderElement(instance.render(), context, legacyContext);
1778	return html;
1779	}
1780
1781	/**
1782	* Serializes an array of children to string.
1783	*
1784	* @param {import('react').ReactNodeArray} children Children to serialize.
1785	* @param {Object} [context] Context object.
1786	* @param {Object} [legacyContext] Legacy context object.
1787	*
1788	* @return {string} Serialized children.
1789	*/
1790	function renderChildren(children, context, legacyContext = {}) {
1791	let result = '';
1792	children = Array.isArray(children) ? children : [children];
1793	for (let i = 0; i < children.length; i++) {
1794	const child = children[i];
1795	result += renderElement(child, context, legacyContext);
1796	}
1797	return result;
1798	}
1799
1800	/**
1801	* Renders a props object as a string of HTML attributes.
1802	*
1803	* @param {Object} props Props object.
1804	*
1805	* @return {string} Attributes string.
1806	*/
1807	function renderAttributes(props) {
1808	let result = '';
1809	for (const key in props) {
1810	const attribute = getNormalAttributeName(key);
1811	if (!(0,external_wp_escapeHtml_namespaceObject.isValidAttributeName)(attribute)) {
1812	continue;
1813	}
1814	let value = getNormalAttributeValue(key, props[key]);
1815
1816	// If value is not of serializable type, skip.
1817	if (!ATTRIBUTES_TYPES.has(typeof value)) {
1818	continue;
1819	}
1820
1821	// Don't render internal attribute names.
1822	if (isInternalAttribute(key)) {
1823	continue;
1824	}
1825	const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute);
1826
1827	// Boolean attribute should be omitted outright if its value is false.
1828	if (isBooleanAttribute && value === false) {
1829	continue;
1830	}
1831	const isMeaningfulAttribute = isBooleanAttribute \|\| hasPrefix(key, ['data-', 'aria-']) \|\| ENUMERATED_ATTRIBUTES.has(attribute);
1832
1833	// Only write boolean value as attribute if meaningful.
1834	if (typeof value === 'boolean' && !isMeaningfulAttribute) {
1835	continue;
1836	}
1837	result += ' ' + attribute;
1838
1839	// Boolean attributes should write attribute name, but without value.
1840	// Mere presence of attribute name is effective truthiness.
1841	if (isBooleanAttribute) {
1842	continue;
1843	}
1844	if (typeof value === 'string') {
1845	value = (0,external_wp_escapeHtml_namespaceObject.escapeAttribute)(value);
1846	}
1847	result += '="' + value + '"';
1848	}
1849	return result;
1850	}
1851
1852	/**
1853	* Renders a style object as a string attribute value.
1854	*
1855	* @param {Object} style Style object.
1856	*
1857	* @return {string} Style attribute value.
1858	*/
1859	function renderStyle(style) {
1860	// Only generate from object, e.g. tolerate string value.
1861	if (!isPlainObject(style)) {
1862	return style;
1863	}
1864	let result;
1865	for (const property in style) {
1866	const value = style[property];
1867	if (null === value \|\| undefined === value) {
1868	continue;
1869	}
1870	if (result) {
1871	result += ';';
1872	} else {
1873	result = '';
1874	}
1875	const normalName = getNormalStylePropertyName(property);
1876	const normalValue = getNormalStylePropertyValue(property, value);
1877	result += normalName + ':' + normalValue;
1878	}
1879	return result;
1880	}
1881	/* harmony default export */ const serialize = (renderElement);
1882
1883	;// CONCATENATED MODULE: ./packages/element/build-module/index.js
1884
1885
1886
1887
1888
1889
1890
1891
1892	})();
1893
1894	(window.wp = window.wp \|\| {}).element = __webpack_exports__;
1895	/******/ })()
1896	;