"use strict";
var wp;
(wp ||= {}).element = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// vendor-external:react
var require_react = __commonJS({
"vendor-external:react"(exports, module) {
module.exports = window.React;
}
});
// vendor-external:react-dom
var require_react_dom = __commonJS({
"vendor-external:react-dom"(exports, module) {
module.exports = window.ReactDOM;
}
});
// node_modules/react-dom/client.js
var require_client = __commonJS({
"node_modules/react-dom/client.js"(exports) {
"use strict";
var m = require_react_dom();
if (false) {
exports.createRoot = m.createRoot;
exports.hydrateRoot = m.hydrateRoot;
} else {
i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
exports.createRoot = function(c, o) {
i.usingClientEntryPoint = true;
try {
return m.createRoot(c, o);
} finally {
i.usingClientEntryPoint = false;
}
};
exports.hydrateRoot = function(c, h, o) {
i.usingClientEntryPoint = true;
try {
return m.hydrateRoot(c, h, o);
} finally {
i.usingClientEntryPoint = false;
}
};
}
var i;
}
});
// package-external:@wordpress/escape-html
var require_escape_html = __commonJS({
"package-external:@wordpress/escape-html"(exports, module) {
module.exports = window.wp.escapeHtml;
}
});
// packages/element/build-module/index.mjs
var index_exports = {};
__export(index_exports, {
Children: () => import_react.Children,
Component: () => import_react.Component,
Fragment: () => import_react.Fragment,
Platform: () => platform_default,
PureComponent: () => import_react.PureComponent,
RawHTML: () => RawHTML,
StrictMode: () => import_react.StrictMode,
Suspense: () => import_react.Suspense,
cloneElement: () => import_react.cloneElement,
concatChildren: () => concatChildren,
createContext: () => import_react.createContext,
createElement: () => import_react.createElement,
createInterpolateElement: () => create_interpolate_element_default,
createPortal: () => import_react_dom.createPortal,
createRef: () => import_react.createRef,
createRoot: () => import_client.createRoot,
findDOMNode: () => import_react_dom.findDOMNode,
flushSync: () => import_react_dom.flushSync,
forwardRef: () => import_react.forwardRef,
hydrate: () => import_react_dom.hydrate,
hydrateRoot: () => import_client.hydrateRoot,
isEmptyElement: () => isEmptyElement,
isValidElement: () => import_react.isValidElement,
lazy: () => import_react.lazy,
memo: () => import_react.memo,
render: () => import_react_dom.render,
renderToString: () => serialize_default,
startTransition: () => import_react.startTransition,
switchChildrenNodeName: () => switchChildrenNodeName,
unmountComponentAtNode: () => import_react_dom.unmountComponentAtNode,
useCallback: () => import_react.useCallback,
useContext: () => import_react.useContext,
useDebugValue: () => import_react.useDebugValue,
useDeferredValue: () => import_react.useDeferredValue,
useEffect: () => import_react.useEffect,
useId: () => import_react.useId,
useImperativeHandle: () => import_react.useImperativeHandle,
useInsertionEffect: () => import_react.useInsertionEffect,
useLayoutEffect: () => import_react.useLayoutEffect,
useMemo: () => import_react.useMemo,
useReducer: () => import_react.useReducer,
useRef: () => import_react.useRef,
useState: () => import_react.useState,
useSyncExternalStore: () => import_react.useSyncExternalStore,
useTransition: () => import_react.useTransition
});
// packages/element/build-module/react.mjs
var import_react = __toESM(require_react(), 1);
function concatChildren(...childrenArguments) {
return childrenArguments.reduce(
(accumulator, children, i) => {
import_react.Children.forEach(children, (child, j) => {
if ((0, import_react.isValidElement)(child) && typeof child !== "string") {
child = (0, import_react.cloneElement)(child, {
key: [i, j].join()
});
}
accumulator.push(child);
});
return accumulator;
},
[]
);
}
function switchChildrenNodeName(children, nodeName) {
return children && import_react.Children.map(children, (elt, index) => {
if (typeof elt?.valueOf() === "string") {
return (0, import_react.createElement)(nodeName, { key: index }, elt);
}
if (!(0, import_react.isValidElement)(elt)) {
return elt;
}
const { children: childrenProp, ...props } = elt.props;
return (0, import_react.createElement)(
nodeName,
{ key: index, ...props },
childrenProp
);
});
}
// packages/element/build-module/create-interpolate-element.mjs
var indoc;
var offset;
var output;
var stack;
var tokenizer = /<(\/)?(\w+)\s*(\/)?>/g;
function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) {
return {
element,
tokenStart,
tokenLength,
prevOffset,
leadingTextStart,
children: []
};
}
var createInterpolateElement = (interpolatedString, conversionMap) => {
indoc = interpolatedString;
offset = 0;
output = [];
stack = [];
tokenizer.lastIndex = 0;
if (!isValidConversionMap(conversionMap)) {
throw new TypeError(
"The conversionMap provided is not valid. It must be an object with values that are React Elements"
);
}
do {
} while (proceed(conversionMap));
return (0, import_react.createElement)(import_react.Fragment, null, ...output);
};
var isValidConversionMap = (conversionMap) => {
const isObject2 = typeof conversionMap === "object" && conversionMap !== null;
const values = isObject2 && Object.values(conversionMap);
return isObject2 && values.length > 0 && values.every((element) => (0, import_react.isValidElement)(element));
};
function proceed(conversionMap) {
const next = nextToken();
const [tokenType, name, startOffset, tokenLength] = next;
const stackDepth = stack.length;
const leadingTextStart = startOffset > offset ? offset : null;
if (name && !conversionMap[name]) {
addText();
return false;
}
switch (tokenType) {
case "no-more-tokens":
if (stackDepth !== 0) {
const { leadingTextStart: stackLeadingText, tokenStart } = stack.pop();
output.push(indoc.substr(stackLeadingText, tokenStart));
}
addText();
return false;
case "self-closed":
if (0 === stackDepth) {
if (null !== leadingTextStart) {
output.push(
indoc.substr(
leadingTextStart,
startOffset - leadingTextStart
)
);
}
output.push(conversionMap[name]);
offset = startOffset + tokenLength;
return true;
}
addChild(
createFrame(conversionMap[name], startOffset, tokenLength)
);
offset = startOffset + tokenLength;
return true;
case "opener":
stack.push(
createFrame(
conversionMap[name],
startOffset,
tokenLength,
startOffset + tokenLength,
leadingTextStart
)
);
offset = startOffset + tokenLength;
return true;
case "closer":
if (1 === stackDepth) {
closeOuterElement(startOffset);
offset = startOffset + tokenLength;
return true;
}
const stackTop = stack.pop();
const text = indoc.substr(
stackTop.prevOffset,
startOffset - stackTop.prevOffset
);
stackTop.children.push(text);
stackTop.prevOffset = startOffset + tokenLength;
const frame = createFrame(
stackTop.element,
stackTop.tokenStart,
stackTop.tokenLength,
startOffset + tokenLength
);
frame.children = stackTop.children;
addChild(frame);
offset = startOffset + tokenLength;
return true;
default:
addText();
return false;
}
}
function nextToken() {
const matches = tokenizer.exec(indoc);
if (null === matches) {
return ["no-more-tokens"];
}
const startedAt = matches.index;
const [match, isClosing, name, isSelfClosed] = matches;
const length = match.length;
if (isSelfClosed) {
return ["self-closed", name, startedAt, length];
}
if (isClosing) {
return ["closer", name, startedAt, length];
}
return ["opener", name, startedAt, length];
}
function addText() {
const length = indoc.length - offset;
if (0 === length) {
return;
}
output.push(indoc.substr(offset, length));
}
function addChild(frame) {
const { element, tokenStart, tokenLength, prevOffset, children } = frame;
const parent = stack[stack.length - 1];
const text = indoc.substr(
parent.prevOffset,
tokenStart - parent.prevOffset
);
if (text) {
parent.children.push(text);
}
parent.children.push((0, import_react.cloneElement)(element, null, ...children));
parent.prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength;
}
function closeOuterElement(endOffset) {
const { element, leadingTextStart, prevOffset, tokenStart, children } = stack.pop();
const text = endOffset ? indoc.substr(prevOffset, endOffset - prevOffset) : indoc.substr(prevOffset);
if (text) {
children.push(text);
}
if (null !== leadingTextStart) {
output.push(
indoc.substr(leadingTextStart, tokenStart - leadingTextStart)
);
}
output.push((0, import_react.cloneElement)(element, null, ...children));
}
var create_interpolate_element_default = createInterpolateElement;
// packages/element/build-module/react-platform.mjs
var import_react_dom = __toESM(require_react_dom(), 1);
var import_client = __toESM(require_client(), 1);
// packages/element/build-module/utils.mjs
var isEmptyElement = (element) => {
if (typeof element === "number") {
return false;
}
if (typeof element?.valueOf() === "string" || Array.isArray(element)) {
return !element.length;
}
return !element;
};
// packages/element/build-module/platform.mjs
var Platform = {
/** Platform identifier. Will always be `'web'` in this module. */
OS: "web",
/**
* Select a value based on the platform.
*
* @template T
* @param spec - Object with optional platform-specific values.
* @return The selected value.
*/
select(spec) {
return "web" in spec ? spec.web : spec.default;
},
/** Whether the platform is web */
isWeb: true
};
var platform_default = Platform;
// node_modules/is-plain-object/dist/is-plain-object.mjs
function isObject(o) {
return Object.prototype.toString.call(o) === "[object Object]";
}
function isPlainObject(o) {
var ctor, prot;
if (isObject(o) === false) return false;
ctor = o.constructor;
if (ctor === void 0) return true;
prot = ctor.prototype;
if (isObject(prot) === false) return false;
if (prot.hasOwnProperty("isPrototypeOf") === false) {
return false;
}
return true;
}
// node_modules/tslib/tslib.es6.mjs
var __assign = function() {
__assign = Object.assign || function __assign2(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
// node_modules/lower-case/dist.es2015/index.js
function lowerCase(str) {
return str.toLowerCase();
}
// node_modules/no-case/dist.es2015/index.js
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
function noCase(input, options) {
if (options === void 0) {
options = {};
}
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;
var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
var start = 0;
var end = result.length;
while (result.charAt(start) === "\0")
start++;
while (result.charAt(end - 1) === "\0")
end--;
return result.slice(start, end).split("\0").map(transform).join(delimiter);
}
function replace(input, re, value) {
if (re instanceof RegExp)
return input.replace(re, value);
return re.reduce(function(input2, re2) {
return input2.replace(re2, value);
}, input);
}
// node_modules/dot-case/dist.es2015/index.js
function dotCase(input, options) {
if (options === void 0) {
options = {};
}
return noCase(input, __assign({ delimiter: "." }, options));
}
// node_modules/param-case/dist.es2015/index.js
function paramCase(input, options) {
if (options === void 0) {
options = {};
}
return dotCase(input, __assign({ delimiter: "-" }, options));
}
// packages/element/build-module/serialize.mjs
var import_escape_html = __toESM(require_escape_html(), 1);
// packages/element/build-module/raw-html.mjs
function RawHTML({ children, ...props }) {
let rawHtml = "";
import_react.Children.toArray(children).forEach((child) => {
if (typeof child === "string" && child.trim() !== "") {
rawHtml += child;
}
});
return (0, import_react.createElement)("div", {
dangerouslySetInnerHTML: { __html: rawHtml },
...props
});
}
// packages/element/build-module/serialize.mjs
var Context = (0, import_react.createContext)(void 0);
Context.displayName = "ElementContext";
var { Provider, Consumer } = Context;
var ForwardRef = (0, import_react.forwardRef)(() => {
return null;
});
var ATTRIBUTES_TYPES = /* @__PURE__ */ new Set(["string", "boolean", "number"]);
var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
"area",
"base",
"br",
"col",
"command",
"embed",
"hr",
"img",
"input",
"keygen",
"link",
"meta",
"param",
"source",
"track",
"wbr"
]);
var BOOLEAN_ATTRIBUTES = /* @__PURE__ */ 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"
]);
var ENUMERATED_ATTRIBUTES = /* @__PURE__ */ 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"
]);
var CSS_PROPERTIES_SUPPORTS_UNITLESS = /* @__PURE__ */ 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"
]);
function hasPrefix(string, prefixes) {
return prefixes.some((prefix) => string.indexOf(prefix) === 0);
}
function isInternalAttribute(attribute) {
return "key" === attribute || "children" === attribute;
}
function getNormalAttributeValue(attribute, value) {
switch (attribute) {
case "style":
return renderStyle(value);
}
return value;
}
var 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) => {
map[attribute.toLowerCase()] = attribute;
return map;
},
{}
);
var 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) => {
map[attribute.toLowerCase()] = attribute;
return map;
},
{}
);
var 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) => {
map[attribute.replace(":", "").toLowerCase()] = attribute;
return map;
},
{}
);
function getNormalAttributeName(attribute) {
switch (attribute) {
case "htmlFor":
return "for";
case "className":
return "class";
}
const attributeLowerCase = attribute.toLowerCase();
if (CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]) {
return CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase];
} else if (SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]) {
return paramCase(
SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]
);
} else if (SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]) {
return SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase];
}
return attributeLowerCase;
}
function getNormalStylePropertyName(property) {
if (property.startsWith("--")) {
return property;
}
if (hasPrefix(property, ["ms", "O", "Moz", "Webkit"])) {
return "-" + paramCase(property);
}
return paramCase(property);
}
function getNormalStylePropertyValue(property, value) {
if (typeof value === "number" && 0 !== value && !hasPrefix(property, ["--"]) && !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) {
return value + "px";
}
return value;
}
function renderElement(element, context, legacyContext = {}) {
if (null === element || void 0 === element || false === element) {
return "";
}
if (Array.isArray(element)) {
return renderChildren(element, context, legacyContext);
}
switch (typeof element) {
case "string":
return (0, import_escape_html.escapeHTML)(element);
case "number":
return element.toString();
}
const { type, props } = element;
switch (type) {
case import_react.StrictMode:
case import_react.Fragment:
return renderChildren(props.children, context, legacyContext);
case RawHTML:
const { children, ...wrapperProps } = props;
return renderNativeComponent(
!Object.keys(wrapperProps).length ? null : "div",
{
...wrapperProps,
dangerouslySetInnerHTML: { __html: children }
},
context,
legacyContext
);
}
switch (typeof type) {
case "string":
return renderNativeComponent(type, props, context, legacyContext);
case "function":
if (type.prototype && typeof type.prototype.render === "function") {
return renderComponent(type, props, context, legacyContext);
}
return renderElement(
type(props, legacyContext),
context,
legacyContext
);
}
switch (type && type.$$typeof) {
case Provider.$$typeof:
return renderChildren(props.children, props.value, legacyContext);
case Consumer.$$typeof:
return renderElement(
props.children(context || type._currentValue),
context,
legacyContext
);
case ForwardRef.$$typeof:
return renderElement(
type.render(props),
context,
legacyContext
);
}
return "";
}
function renderNativeComponent(type, props, context, legacyContext = {}) {
let content = "";
if (type === "textarea" && props.hasOwnProperty("value")) {
content = renderChildren(props.value, context, legacyContext);
const { value, ...restProps } = props;
props = restProps;
} else if (props.dangerouslySetInnerHTML && typeof props.dangerouslySetInnerHTML.__html === "string") {
content = props.dangerouslySetInnerHTML.__html;
} else if (typeof props.children !== "undefined") {
content = renderChildren(props.children, context, legacyContext);
}
if (!type) {
return content;
}
const attributes = renderAttributes(props);
if (SELF_CLOSING_TAGS.has(type)) {
return "<" + type + attributes + "/>";
}
return "<" + type + attributes + ">" + content + "</" + type + ">";
}
function renderComponent(Component2, props, context, legacyContext = {}) {
const instance = new Component2(props, legacyContext);
if (typeof instance.getChildContext === "function") {
Object.assign(legacyContext, instance.getChildContext());
}
const html = renderElement(instance.render(), context, legacyContext);
return html;
}
function renderChildren(children, context, legacyContext = {}) {
let result = "";
const childrenArray = Array.isArray(children) ? children : [children];
for (let i = 0; i < childrenArray.length; i++) {
const child = childrenArray[i];
result += renderElement(child, context, legacyContext);
}
return result;
}
function renderAttributes(props) {
let result = "";
for (const key in props) {
const attribute = getNormalAttributeName(key);
if (!(0, import_escape_html.isValidAttributeName)(attribute)) {
continue;
}
let value = getNormalAttributeValue(key, props[key]);
if (!ATTRIBUTES_TYPES.has(typeof value)) {
continue;
}
if (isInternalAttribute(key)) {
continue;
}
const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute);
if (isBooleanAttribute && value === false) {
continue;
}
const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, ["data-", "aria-"]) || ENUMERATED_ATTRIBUTES.has(attribute);
if (typeof value === "boolean" && !isMeaningfulAttribute) {
continue;
}
result += " " + attribute;
if (isBooleanAttribute) {
continue;
}
if (typeof value === "string") {
value = (0, import_escape_html.escapeAttribute)(value);
}
result += '="' + value + '"';
}
return result;
}
function renderStyle(style) {
if (!isPlainObject(style)) {
return style;
}
let result;
const styleObj = style;
for (const property in styleObj) {
const value = styleObj[property];
if (null === value || void 0 === value) {
continue;
}
if (result) {
result += ";";
} else {
result = "";
}
const normalName = getNormalStylePropertyName(property);
const normalValue = getNormalStylePropertyValue(property, value);
result += normalName + ":" + normalValue;
}
return result;
}
var serialize_default = renderElement;
return __toCommonJS(index_exports);
})();
/*! Bundled license information:
is-plain-object/dist/is-plain-object.mjs:
(*!
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*)
*/