@stokr/components-library 3.0.66 → 3.0.67

package/dist/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js

@@ -0,0 +1,92 @@
+import { __require as requireReactIs } from "../../react-is/index.js";
+var hoistNonReactStatics_cjs;
+var hasRequiredHoistNonReactStatics_cjs;
+function requireHoistNonReactStatics_cjs() {
+  if (hasRequiredHoistNonReactStatics_cjs) return hoistNonReactStatics_cjs;
+  hasRequiredHoistNonReactStatics_cjs = 1;
+  var reactIs = requireReactIs();
+  var REACT_STATICS = {
+    childContextTypes: true,
+    contextType: true,
+    contextTypes: true,
+    defaultProps: true,
+    displayName: true,
+    getDefaultProps: true,
+    getDerivedStateFromError: true,
+    getDerivedStateFromProps: true,
+    mixins: true,
+    propTypes: true,
+    type: true
+  };
+  var KNOWN_STATICS = {
+    name: true,
+    length: true,
+    prototype: true,
+    caller: true,
+    callee: true,
+    arguments: true,
+    arity: true
+  };
+  var FORWARD_REF_STATICS = {
+    "$$typeof": true,
+    render: true,
+    defaultProps: true,
+    displayName: true,
+    propTypes: true
+  };
+  var MEMO_STATICS = {
+    "$$typeof": true,
+    compare: true,
+    defaultProps: true,
+    displayName: true,
+    propTypes: true,
+    type: true
+  };
+  var TYPE_STATICS = {};
+  TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+  TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+  function getStatics(component) {
+    if (reactIs.isMemo(component)) {
+      return MEMO_STATICS;
+    }
+    return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
+  }
+  var defineProperty = Object.defineProperty;
+  var getOwnPropertyNames = Object.getOwnPropertyNames;
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var getPrototypeOf = Object.getPrototypeOf;
+  var objectPrototype = Object.prototype;
+  function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+    if (typeof sourceComponent !== "string") {
+      if (objectPrototype) {
+        var inheritedComponent = getPrototypeOf(sourceComponent);
+        if (inheritedComponent && inheritedComponent !== objectPrototype) {
+          hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+        }
+      }
+      var keys = getOwnPropertyNames(sourceComponent);
+      if (getOwnPropertySymbols) {
+        keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+      }
+      var targetStatics = getStatics(targetComponent);
+      var sourceStatics = getStatics(sourceComponent);
+      for (var i = 0; i < keys.length; ++i) {
+        var key = keys[i];
+        if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+          var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+          try {
+            defineProperty(targetComponent, key, descriptor);
+          } catch (e) {
+          }
+        }
+      }
+    }
+    return targetComponent;
+  }
+  hoistNonReactStatics_cjs = hoistNonReactStatics;
+  return hoistNonReactStatics_cjs;
+}
+export {
+  requireHoistNonReactStatics_cjs as __require
+};

package/dist/node_modules/html-dom-parser/lib/client/constants.js

@@ -0,0 +1,55 @@
+import { __exports as constants } from "../../../../_virtual/constants.js";
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.CARRIAGE_RETURN_PLACEHOLDER_REGEX = exports$1.CARRIAGE_RETURN_PLACEHOLDER = exports$1.CARRIAGE_RETURN_REGEX = exports$1.CARRIAGE_RETURN = exports$1.CASE_SENSITIVE_TAG_NAMES_MAP = exports$1.CASE_SENSITIVE_TAG_NAMES = void 0;
+    exports$1.CASE_SENSITIVE_TAG_NAMES = [
+      "animateMotion",
+      "animateTransform",
+      "clipPath",
+      "feBlend",
+      "feColorMatrix",
+      "feComponentTransfer",
+      "feComposite",
+      "feConvolveMatrix",
+      "feDiffuseLighting",
+      "feDisplacementMap",
+      "feDropShadow",
+      "feFlood",
+      "feFuncA",
+      "feFuncB",
+      "feFuncG",
+      "feFuncR",
+      "feGaussianBlur",
+      "feImage",
+      "feMerge",
+      "feMergeNode",
+      "feMorphology",
+      "feOffset",
+      "fePointLight",
+      "feSpecularLighting",
+      "feSpotLight",
+      "feTile",
+      "feTurbulence",
+      "foreignObject",
+      "linearGradient",
+      "radialGradient",
+      "textPath"
+    ];
+    exports$1.CASE_SENSITIVE_TAG_NAMES_MAP = exports$1.CASE_SENSITIVE_TAG_NAMES.reduce(function(accumulator, tagName) {
+      accumulator[tagName.toLowerCase()] = tagName;
+      return accumulator;
+    }, {});
+    exports$1.CARRIAGE_RETURN = "\r";
+    exports$1.CARRIAGE_RETURN_REGEX = new RegExp(exports$1.CARRIAGE_RETURN, "g");
+    exports$1.CARRIAGE_RETURN_PLACEHOLDER = "__HTML_DOM_PARSER_CARRIAGE_RETURN_PLACEHOLDER_".concat(Date.now(), "__");
+    exports$1.CARRIAGE_RETURN_PLACEHOLDER_REGEX = new RegExp(exports$1.CARRIAGE_RETURN_PLACEHOLDER, "g");
+  })(constants);
+  return constants;
+}
+export {
+  requireConstants as __require
+};

package/dist/node_modules/html-dom-parser/lib/client/domparser.js

@@ -0,0 +1,96 @@
+import { __exports as domparser } from "../../../../_virtual/domparser.js";
+import { __require as requireUtilities } from "./utilities.js";
+var hasRequiredDomparser;
+function requireDomparser() {
+  if (hasRequiredDomparser) return domparser;
+  hasRequiredDomparser = 1;
+  Object.defineProperty(domparser, "__esModule", { value: true });
+  domparser.default = domparser$1;
+  var utilities_1 = requireUtilities();
+  var HTML = "html";
+  var HEAD = "head";
+  var BODY = "body";
+  var FIRST_TAG_REGEX = /<([a-zA-Z]+[0-9]?)/;
+  var HEAD_TAG_REGEX = /<head[^]*>/i;
+  var BODY_TAG_REGEX = /<body[^]*>/i;
+  var parseFromDocument = function(html, tagName) {
+    throw new Error("This browser does not support `document.implementation.createHTMLDocument`");
+  };
+  var parseFromString = function(html, tagName) {
+    throw new Error("This browser does not support `DOMParser.prototype.parseFromString`");
+  };
+  var DOMParser = typeof window === "object" && window.DOMParser;
+  if (typeof DOMParser === "function") {
+    var domParser_1 = new DOMParser();
+    var mimeType_1 = "text/html";
+    parseFromString = function(html, tagName) {
+      if (tagName) {
+        html = "<".concat(tagName, ">").concat(html, "</").concat(tagName, ">");
+      }
+      return domParser_1.parseFromString(html, mimeType_1);
+    };
+    parseFromDocument = parseFromString;
+  }
+  if (typeof document === "object" && document.implementation) {
+    var htmlDocument_1 = document.implementation.createHTMLDocument();
+    parseFromDocument = function(html, tagName) {
+      if (tagName) {
+        var element = htmlDocument_1.documentElement.querySelector(tagName);
+        if (element) {
+          element.innerHTML = html;
+        }
+        return htmlDocument_1;
+      }
+      htmlDocument_1.documentElement.innerHTML = html;
+      return htmlDocument_1;
+    };
+  }
+  var template = typeof document === "object" && document.createElement("template");
+  var parseFromTemplate;
+  if (template && template.content) {
+    parseFromTemplate = function(html) {
+      template.innerHTML = html;
+      return template.content.childNodes;
+    };
+  }
+  function domparser$1(html) {
+    var _a, _b;
+    html = (0, utilities_1.escapeSpecialCharacters)(html);
+    var match = html.match(FIRST_TAG_REGEX);
+    var firstTagName = match && match[1] ? match[1].toLowerCase() : "";
+    switch (firstTagName) {
+      case HTML: {
+        var doc = parseFromString(html);
+        if (!HEAD_TAG_REGEX.test(html)) {
+          var element = doc.querySelector(HEAD);
+          (_a = element === null || element === void 0 ? void 0 : element.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(element);
+        }
+        if (!BODY_TAG_REGEX.test(html)) {
+          var element = doc.querySelector(BODY);
+          (_b = element === null || element === void 0 ? void 0 : element.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(element);
+        }
+        return doc.querySelectorAll(HTML);
+      }
+      case HEAD:
+      case BODY: {
+        var elements = parseFromDocument(html).querySelectorAll(firstTagName);
+        if (BODY_TAG_REGEX.test(html) && HEAD_TAG_REGEX.test(html)) {
+          return elements[0].parentNode.childNodes;
+        }
+        return elements;
+      }
+      // low-level tag or text
+      default: {
+        if (parseFromTemplate) {
+          return parseFromTemplate(html);
+        }
+        var element = parseFromDocument(html, BODY).querySelector(BODY);
+        return element.childNodes;
+      }
+    }
+  }
+  return domparser;
+}
+export {
+  requireDomparser as __require
+};

package/dist/node_modules/html-dom-parser/lib/client/html-to-dom.js

@@ -0,0 +1,31 @@
+import { __exports as htmlToDom } from "../../../../_virtual/html-to-dom.js";
+import { __require as requireDomparser } from "./domparser.js";
+import { __require as requireUtilities } from "./utilities.js";
+var hasRequiredHtmlToDom;
+function requireHtmlToDom() {
+  if (hasRequiredHtmlToDom) return htmlToDom;
+  hasRequiredHtmlToDom = 1;
+  var __importDefault = htmlToDom && htmlToDom.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(htmlToDom, "__esModule", { value: true });
+  htmlToDom.default = HTMLDOMParser;
+  var domparser_1 = __importDefault(requireDomparser());
+  var utilities_1 = requireUtilities();
+  var DIRECTIVE_REGEX = /<(![a-zA-Z\s]+)>/;
+  function HTMLDOMParser(html) {
+    if (typeof html !== "string") {
+      throw new TypeError("First argument must be a string");
+    }
+    if (!html) {
+      return [];
+    }
+    var match = html.match(DIRECTIVE_REGEX);
+    var directive = match ? match[1] : void 0;
+    return (0, utilities_1.formatDOM)((0, domparser_1.default)(html), null, directive);
+  }
+  return htmlToDom;
+}
+export {
+  requireHtmlToDom as __require
+};

package/dist/node_modules/html-dom-parser/lib/client/utilities.js

@@ -0,0 +1,96 @@
+import { __exports as utilities } from "../../../../_virtual/utilities.js";
+import { __require as requireLib } from "../../../domhandler/lib/index.js";
+import { __require as requireConstants } from "./constants.js";
+var hasRequiredUtilities;
+function requireUtilities() {
+  if (hasRequiredUtilities) return utilities;
+  hasRequiredUtilities = 1;
+  Object.defineProperty(utilities, "__esModule", { value: true });
+  utilities.formatAttributes = formatAttributes;
+  utilities.escapeSpecialCharacters = escapeSpecialCharacters;
+  utilities.revertEscapedCharacters = revertEscapedCharacters;
+  utilities.formatDOM = formatDOM;
+  var domhandler_1 = /* @__PURE__ */ requireLib();
+  var constants_1 = requireConstants();
+  function getCaseSensitiveTagName(tagName) {
+    return constants_1.CASE_SENSITIVE_TAG_NAMES_MAP[tagName];
+  }
+  function formatAttributes(attributes) {
+    var map = {};
+    var index = 0;
+    var attributesLength = attributes.length;
+    for (; index < attributesLength; index++) {
+      var attribute = attributes[index];
+      map[attribute.name] = attribute.value;
+    }
+    return map;
+  }
+  function formatTagName(tagName) {
+    tagName = tagName.toLowerCase();
+    var caseSensitiveTagName = getCaseSensitiveTagName(tagName);
+    if (caseSensitiveTagName) {
+      return caseSensitiveTagName;
+    }
+    return tagName;
+  }
+  function escapeSpecialCharacters(html) {
+    return html.replace(constants_1.CARRIAGE_RETURN_REGEX, constants_1.CARRIAGE_RETURN_PLACEHOLDER);
+  }
+  function revertEscapedCharacters(text) {
+    return text.replace(constants_1.CARRIAGE_RETURN_PLACEHOLDER_REGEX, constants_1.CARRIAGE_RETURN);
+  }
+  function formatDOM(nodes, parent, directive) {
+    if (parent === void 0) {
+      parent = null;
+    }
+    var domNodes = [];
+    var current;
+    var index = 0;
+    var nodesLength = nodes.length;
+    for (; index < nodesLength; index++) {
+      var node = nodes[index];
+      switch (node.nodeType) {
+        case 1: {
+          var tagName = formatTagName(node.nodeName);
+          current = new domhandler_1.Element(tagName, formatAttributes(node.attributes));
+          current.children = formatDOM(
+            // template children are on content
+            tagName === "template" ? node.content.childNodes : node.childNodes,
+            current
+          );
+          break;
+        }
+        case 3:
+          current = new domhandler_1.Text(revertEscapedCharacters(node.nodeValue));
+          break;
+        case 8:
+          current = new domhandler_1.Comment(node.nodeValue);
+          break;
+        default:
+          continue;
+      }
+      var prev = domNodes[index - 1] || null;
+      if (prev) {
+        prev.next = current;
+      }
+      current.parent = parent;
+      current.prev = prev;
+      current.next = null;
+      domNodes.push(current);
+    }
+    if (directive) {
+      current = new domhandler_1.ProcessingInstruction(directive.substring(0, directive.indexOf(" ")).toLowerCase(), directive);
+      current.next = domNodes[0] || null;
+      current.parent = parent;
+      domNodes.unshift(current);
+      if (domNodes[1]) {
+        domNodes[1].prev = domNodes[0];
+      }
+    }
+    return domNodes;
+  }
+  return utilities;
+}
+export {
+  requireUtilities as __require
+};

package/dist/node_modules/html-react-parser/esm/index.js

@@ -0,0 +1,5 @@
+import HTMLReactParser from "../../../_virtual/index13.js";
+const parse = HTMLReactParser.default || HTMLReactParser;
+export {
+  parse as default
+};

package/dist/node_modules/html-react-parser/lib/attributes-to-props.js

@@ -0,0 +1,64 @@
+import { __exports as attributesToProps } from "../../../_virtual/attributes-to-props.js";
+import { __require as requireLib } from "../../react-property/lib/index.js";
+import { __require as requireUtilities } from "./utilities.js";
+var hasRequiredAttributesToProps;
+function requireAttributesToProps() {
+  if (hasRequiredAttributesToProps) return attributesToProps;
+  hasRequiredAttributesToProps = 1;
+  Object.defineProperty(attributesToProps, "__esModule", { value: true });
+  attributesToProps.default = attributesToProps$1;
+  var react_property_1 = requireLib();
+  var utilities_1 = requireUtilities();
+  var UNCONTROLLED_COMPONENT_ATTRIBUTES = ["checked", "value"];
+  var UNCONTROLLED_COMPONENT_NAMES = ["input", "select", "textarea"];
+  var valueOnlyInputs = {
+    reset: true,
+    submit: true
+  };
+  function attributesToProps$1(attributes, nodeName) {
+    if (attributes === void 0) {
+      attributes = {};
+    }
+    var props = {};
+    var isInputValueOnly = Boolean(attributes.type && valueOnlyInputs[attributes.type]);
+    for (var attributeName in attributes) {
+      var attributeValue = attributes[attributeName];
+      if ((0, react_property_1.isCustomAttribute)(attributeName)) {
+        props[attributeName] = attributeValue;
+        continue;
+      }
+      var attributeNameLowerCased = attributeName.toLowerCase();
+      var propName = getPropName(attributeNameLowerCased);
+      if (propName) {
+        var propertyInfo = (0, react_property_1.getPropertyInfo)(propName);
+        if (UNCONTROLLED_COMPONENT_ATTRIBUTES.includes(propName) && UNCONTROLLED_COMPONENT_NAMES.includes(nodeName) && !isInputValueOnly) {
+          propName = getPropName("default" + attributeNameLowerCased);
+        }
+        props[propName] = attributeValue;
+        switch (propertyInfo && propertyInfo.type) {
+          case react_property_1.BOOLEAN:
+            props[propName] = true;
+            break;
+          case react_property_1.OVERLOADED_BOOLEAN:
+            if (attributeValue === "") {
+              props[propName] = true;
+            }
+            break;
+        }
+        continue;
+      }
+      if (utilities_1.PRESERVE_CUSTOM_ATTRIBUTES) {
+        props[attributeName] = attributeValue;
+      }
+    }
+    (0, utilities_1.setStyleProp)(attributes.style, props);
+    return props;
+  }
+  function getPropName(attributeName) {
+    return react_property_1.possibleStandardNames[attributeName];
+  }
+  return attributesToProps;
+}
+export {
+  requireAttributesToProps as __require
+};

package/dist/node_modules/html-react-parser/lib/dom-to-react.js

@@ -0,0 +1,99 @@
+import { __exports as domToReact } from "../../../_virtual/dom-to-react.js";
+import React__default from "react";
+import { __require as requireAttributesToProps } from "./attributes-to-props.js";
+import { __require as requireUtilities } from "./utilities.js";
+var hasRequiredDomToReact;
+function requireDomToReact() {
+  if (hasRequiredDomToReact) return domToReact;
+  hasRequiredDomToReact = 1;
+  var __importDefault = domToReact && domToReact.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(domToReact, "__esModule", { value: true });
+  domToReact.default = domToReact$1;
+  var react_1 = React__default;
+  var attributes_to_props_1 = __importDefault(requireAttributesToProps());
+  var utilities_1 = requireUtilities();
+  var React = {
+    cloneElement: react_1.cloneElement,
+    createElement: react_1.createElement,
+    isValidElement: react_1.isValidElement
+  };
+  function domToReact$1(nodes, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    var reactElements = [];
+    var hasReplace = typeof options.replace === "function";
+    var transform = options.transform || utilities_1.returnFirstArg;
+    var _a = options.library || React, cloneElement = _a.cloneElement, createElement = _a.createElement, isValidElement = _a.isValidElement;
+    var nodesLength = nodes.length;
+    for (var index = 0; index < nodesLength; index++) {
+      var node = nodes[index];
+      if (hasReplace) {
+        var replaceElement = options.replace(node, index);
+        if (isValidElement(replaceElement)) {
+          if (nodesLength > 1) {
+            replaceElement = cloneElement(replaceElement, {
+              key: replaceElement.key || index
+            });
+          }
+          reactElements.push(transform(replaceElement, node, index));
+          continue;
+        }
+      }
+      if (node.type === "text") {
+        var isWhitespace = !node.data.trim().length;
+        if (isWhitespace && node.parent && !(0, utilities_1.canTextBeChildOfNode)(node.parent)) {
+          continue;
+        }
+        if (options.trim && isWhitespace) {
+          continue;
+        }
+        reactElements.push(transform(node.data, node, index));
+        continue;
+      }
+      var element = node;
+      var props = {};
+      if (skipAttributesToProps(element)) {
+        (0, utilities_1.setStyleProp)(element.attribs.style, element.attribs);
+        props = element.attribs;
+      } else if (element.attribs) {
+        props = (0, attributes_to_props_1.default)(element.attribs, element.name);
+      }
+      var children = void 0;
+      switch (node.type) {
+        case "script":
+        case "style":
+          if (node.children[0]) {
+            props.dangerouslySetInnerHTML = {
+              __html: node.children[0].data
+            };
+          }
+          break;
+        case "tag":
+          if (node.name === "textarea" && node.children[0]) {
+            props.defaultValue = node.children[0].data;
+          } else if (node.children && node.children.length) {
+            children = domToReact$1(node.children, options);
+          }
+          break;
+        // skip all other cases (e.g., comment)
+        default:
+          continue;
+      }
+      if (nodesLength > 1) {
+        props.key = index;
+      }
+      reactElements.push(transform(createElement(node.name, props, children), node, index));
+    }
+    return reactElements.length === 1 ? reactElements[0] : reactElements;
+  }
+  function skipAttributesToProps(node) {
+    return utilities_1.PRESERVE_CUSTOM_ATTRIBUTES && node.type === "tag" && (0, utilities_1.isCustomComponent)(node.name, node.attribs);
+  }
+  return domToReact;
+}
+export {
+  requireDomToReact as __require
+};

package/dist/node_modules/html-react-parser/lib/index.js

@@ -0,0 +1,51 @@
+import { __exports as lib } from "../../../_virtual/index23.js";
+import { __require as requireHtmlToDom } from "../../html-dom-parser/lib/client/html-to-dom.js";
+import { __require as requireAttributesToProps } from "./attributes-to-props.js";
+import { __require as requireDomToReact } from "./dom-to-react.js";
+import { __require as requireLib$1 } from "../../domhandler/lib/index.js";
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  (function(exports$1) {
+    var __importDefault = lib && lib.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.htmlToDOM = exports$1.domToReact = exports$1.attributesToProps = exports$1.Text = exports$1.ProcessingInstruction = exports$1.Element = exports$1.Comment = void 0;
+    exports$1.default = HTMLReactParser;
+    var html_dom_parser_1 = __importDefault(requireHtmlToDom());
+    exports$1.htmlToDOM = html_dom_parser_1.default;
+    var attributes_to_props_1 = __importDefault(requireAttributesToProps());
+    exports$1.attributesToProps = attributes_to_props_1.default;
+    var dom_to_react_1 = __importDefault(requireDomToReact());
+    exports$1.domToReact = dom_to_react_1.default;
+    var domhandler_1 = /* @__PURE__ */ requireLib$1();
+    Object.defineProperty(exports$1, "Comment", { enumerable: true, get: function() {
+      return domhandler_1.Comment;
+    } });
+    Object.defineProperty(exports$1, "Element", { enumerable: true, get: function() {
+      return domhandler_1.Element;
+    } });
+    Object.defineProperty(exports$1, "ProcessingInstruction", { enumerable: true, get: function() {
+      return domhandler_1.ProcessingInstruction;
+    } });
+    Object.defineProperty(exports$1, "Text", { enumerable: true, get: function() {
+      return domhandler_1.Text;
+    } });
+    var domParserOptions = { lowerCaseAttributeNames: false };
+    function HTMLReactParser(html, options) {
+      if (typeof html !== "string") {
+        throw new TypeError("First argument must be a string");
+      }
+      if (!html) {
+        return [];
+      }
+      return (0, dom_to_react_1.default)((0, html_dom_parser_1.default)(html, (options === null || options === void 0 ? void 0 : options.htmlparser2) || domParserOptions), options);
+    }
+  })(lib);
+  return lib;
+}
+export {
+  requireLib as __require
+};

package/dist/node_modules/html-react-parser/lib/utilities.js

@@ -0,0 +1,79 @@
+import { __exports as utilities } from "../../../_virtual/utilities2.js";
+import React__default from "react";
+import { __require as requireCjs } from "../../style-to-js/cjs/index.js";
+var hasRequiredUtilities;
+function requireUtilities() {
+  if (hasRequiredUtilities) return utilities;
+  hasRequiredUtilities = 1;
+  (function(exports$1) {
+    var __importDefault = utilities && utilities.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.returnFirstArg = exports$1.canTextBeChildOfNode = exports$1.ELEMENTS_WITH_NO_TEXT_CHILDREN = exports$1.PRESERVE_CUSTOM_ATTRIBUTES = void 0;
+    exports$1.isCustomComponent = isCustomComponent;
+    exports$1.setStyleProp = setStyleProp;
+    var react_1 = React__default;
+    var style_to_js_1 = __importDefault(requireCjs());
+    var RESERVED_SVG_MATHML_ELEMENTS = /* @__PURE__ */ new Set([
+      "annotation-xml",
+      "color-profile",
+      "font-face",
+      "font-face-src",
+      "font-face-uri",
+      "font-face-format",
+      "font-face-name",
+      "missing-glyph"
+    ]);
+    function isCustomComponent(tagName, props) {
+      if (!tagName.includes("-")) {
+        return Boolean(props && typeof props.is === "string");
+      }
+      if (RESERVED_SVG_MATHML_ELEMENTS.has(tagName)) {
+        return false;
+      }
+      return true;
+    }
+    var styleOptions = {
+      reactCompat: true
+    };
+    function setStyleProp(style, props) {
+      if (typeof style !== "string") {
+        return;
+      }
+      if (!style.trim()) {
+        props.style = {};
+        return;
+      }
+      try {
+        props.style = (0, style_to_js_1.default)(style, styleOptions);
+      } catch (error) {
+        props.style = {};
+      }
+    }
+    exports$1.PRESERVE_CUSTOM_ATTRIBUTES = Number(react_1.version.split(".")[0]) >= 16;
+    exports$1.ELEMENTS_WITH_NO_TEXT_CHILDREN = /* @__PURE__ */ new Set([
+      "tr",
+      "tbody",
+      "thead",
+      "tfoot",
+      "colgroup",
+      "table",
+      "head",
+      "html",
+      "frameset"
+    ]);
+    var canTextBeChildOfNode = function(node) {
+      return !exports$1.ELEMENTS_WITH_NO_TEXT_CHILDREN.has(node.name);
+    };
+    exports$1.canTextBeChildOfNode = canTextBeChildOfNode;
+    var returnFirstArg = function(arg) {
+      return arg;
+    };
+    exports$1.returnFirstArg = returnFirstArg;
+  })(utilities);
+  return utilities;
+}
+export {
+  requireUtilities as __require
+};