@eightshift/ui-components 5.0.9 → 5.1.0

package/dist/{react-jsx-parser.min-DZCiis5V.js → react-jsx-parser.min-LF707GK8.js}

@@ -1,13 +1,3 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var _parseJSX, _parseExpression, _parseChainExpression, _parseMemberExpression, _parseName, _parseElement;
 import React__default, { Fragment } from "react";
 function getLocator(source, options) {
   if (options === void 0) {
@@ -385,15 +375,15 @@ function svgToJsxString(svgString) {
 }
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
-var __defProp2 = Object.defineProperty;
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __toESM = (mod, isNodeMode, target) => {
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = __defProp2(target, "default", { value: mod, enumerable: true });
+  const to = __defProp(target, "default", { value: mod, enumerable: true });
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
-      __defProp2(to, key, {
+      __defProp(to, key, {
         get: () => mod[key],
         enumerable: true
       });
@@ -11409,343 +11399,333 @@ function handleNaN(child) {
   return Number.isNaN(child) ? "NaN" : child;
 }
 class JsxParser extends React__default.Component {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "ParsedChildren", null);
-    __privateAdd(this, _parseJSX, (jsx) => {
-      const parser = Parser.extend(AcornJSX.default({
-        autoCloseVoidElements: this.props.autoCloseVoidElements
-      }));
-      const wrappedJsx = `<root>${jsx}</root>`;
-      let parsed = [];
-      try {
-        parsed = parser.parse(wrappedJsx, { ecmaVersion: "latest" });
-        parsed = parsed.body[0].expression.children || [];
-      } catch (error) {
-        if (this.props.showWarnings)
-          console.warn(error);
-        if (this.props.onError)
-          this.props.onError(error);
-        if (this.props.renderError) {
-          return this.props.renderError({ error: String(error) });
-        }
-        return null;
+  static displayName = "JsxParser";
+  static defaultProps = {
+    allowUnknownElements: true,
+    autoCloseVoidElements: false,
+    bindings: {},
+    blacklistedAttrs: [/^on.+/i],
+    blacklistedTags: ["script"],
+    className: "",
+    components: {},
+    componentsOnly: false,
+    disableFragments: false,
+    disableKeyGeneration: false,
+    jsx: "",
+    onError: () => {
+    },
+    showWarnings: false,
+    renderError: void 0,
+    renderInWrapper: true,
+    renderUnrecognized: () => null
+  };
+  ParsedChildren = null;
+  #parseJSX = (jsx) => {
+    const parser = Parser.extend(AcornJSX.default({
+      autoCloseVoidElements: this.props.autoCloseVoidElements
+    }));
+    const wrappedJsx = `<root>${jsx}</root>`;
+    let parsed = [];
+    try {
+      parsed = parser.parse(wrappedJsx, { ecmaVersion: "latest" });
+      parsed = parsed.body[0].expression.children || [];
+    } catch (error) {
+      if (this.props.showWarnings)
+        console.warn(error);
+      if (this.props.onError)
+        this.props.onError(error);
+      if (this.props.renderError) {
+        return this.props.renderError({ error: String(error) });
       }
-      return parsed.map((p) => __privateGet(this, _parseExpression).call(this, p)).filter(Boolean);
-    });
-    __privateAdd(this, _parseExpression, (expression, scope) => {
-      var _a, _b;
-      switch (expression.type) {
-        case "JSXAttribute":
-          if (expression.value === null)
-            return true;
-          return __privateGet(this, _parseExpression).call(this, expression.value, scope);
-        case "JSXElement":
-        case "JSXFragment":
-          return __privateGet(this, _parseElement).call(this, expression, scope);
-        case "JSXExpressionContainer":
-          return __privateGet(this, _parseExpression).call(this, expression.expression, scope);
-        case "JSXText":
-          const key = this.props.disableKeyGeneration ? void 0 : randomHash();
-          return this.props.disableFragments ? expression.value : /* @__PURE__ */ React__default.createElement(Fragment, {
-            key
-          }, expression.value);
-        case "ArrayExpression":
-          return expression.elements.map((ele) => __privateGet(this, _parseExpression).call(this, ele, scope));
-        case "BinaryExpression":
-          const binaryLeft = __privateGet(this, _parseExpression).call(this, expression.left, scope);
-          const binaryRight = __privateGet(this, _parseExpression).call(this, expression.right, scope);
-          let binaryResult;
-          switch (expression.operator) {
-            case "-":
-              binaryResult = binaryLeft - binaryRight;
-              break;
-            case "!=":
-              binaryResult = binaryLeft != binaryRight;
-              break;
-            case "!==":
-              binaryResult = binaryLeft !== binaryRight;
-              break;
-            case "*":
-              binaryResult = binaryLeft * binaryRight;
-              break;
-            case "**":
-              binaryResult = binaryLeft ** binaryRight;
-              break;
-            case "/":
-              binaryResult = binaryLeft / binaryRight;
-              break;
-            case "%":
-              binaryResult = binaryLeft % binaryRight;
-              break;
-            case "+":
-              binaryResult = binaryLeft + binaryRight;
-              break;
-            case "<":
-              binaryResult = binaryLeft < binaryRight;
-              break;
-            case "<=":
-              binaryResult = binaryLeft <= binaryRight;
-              break;
-            case "==":
-              binaryResult = binaryLeft == binaryRight;
-              break;
-            case "===":
-              binaryResult = binaryLeft === binaryRight;
-              break;
-            case ">":
-              binaryResult = binaryLeft > binaryRight;
-              break;
-            case ">=":
-              binaryResult = binaryLeft >= binaryRight;
-              break;
-            default:
-              this.props.onError(new Error(`Unsupported binary operator: ${expression.operator}`));
-              return;
-          }
-          return handleNaN(binaryResult);
-        case "CallExpression":
-          const parsedCallee = __privateGet(this, _parseExpression).call(this, expression.callee, scope);
-          if (parsedCallee === void 0) {
-            if (expression.optional) {
-              throw new NullishShortCircuit();
-            }
-            this.props.onError(new Error(`The expression '${expression.callee}' could not be resolved, resulting in an undefined return value.`));
+      return null;
+    }
+    return parsed.map((p) => this.#parseExpression(p)).filter(Boolean);
+  };
+  #parseExpression = (expression, scope) => {
+    switch (expression.type) {
+      case "JSXAttribute":
+        if (expression.value === null)
+          return true;
+        return this.#parseExpression(expression.value, scope);
+      case "JSXElement":
+      case "JSXFragment":
+        return this.#parseElement(expression, scope);
+      case "JSXExpressionContainer":
+        return this.#parseExpression(expression.expression, scope);
+      case "JSXText":
+        const key = this.props.disableKeyGeneration ? void 0 : randomHash();
+        return this.props.disableFragments ? expression.value : /* @__PURE__ */ React__default.createElement(Fragment, {
+          key
+        }, expression.value);
+      case "ArrayExpression":
+        return expression.elements.map((ele) => this.#parseExpression(ele, scope));
+      case "BinaryExpression":
+        const binaryLeft = this.#parseExpression(expression.left, scope);
+        const binaryRight = this.#parseExpression(expression.right, scope);
+        let binaryResult;
+        switch (expression.operator) {
+          case "-":
+            binaryResult = binaryLeft - binaryRight;
+            break;
+          case "!=":
+            binaryResult = binaryLeft != binaryRight;
+            break;
+          case "!==":
+            binaryResult = binaryLeft !== binaryRight;
+            break;
+          case "*":
+            binaryResult = binaryLeft * binaryRight;
+            break;
+          case "**":
+            binaryResult = binaryLeft ** binaryRight;
+            break;
+          case "/":
+            binaryResult = binaryLeft / binaryRight;
+            break;
+          case "%":
+            binaryResult = binaryLeft % binaryRight;
+            break;
+          case "+":
+            binaryResult = binaryLeft + binaryRight;
+            break;
+          case "<":
+            binaryResult = binaryLeft < binaryRight;
+            break;
+          case "<=":
+            binaryResult = binaryLeft <= binaryRight;
+            break;
+          case "==":
+            binaryResult = binaryLeft == binaryRight;
+            break;
+          case "===":
+            binaryResult = binaryLeft === binaryRight;
+            break;
+          case ">":
+            binaryResult = binaryLeft > binaryRight;
+            break;
+          case ">=":
+            binaryResult = binaryLeft >= binaryRight;
+            break;
+          default:
+            this.props.onError(new Error(`Unsupported binary operator: ${expression.operator}`));
             return;
+        }
+        return handleNaN(binaryResult);
+      case "CallExpression":
+        const parsedCallee = this.#parseExpression(expression.callee, scope);
+        if (parsedCallee === void 0) {
+          if (expression.optional) {
+            throw new NullishShortCircuit();
           }
-          return parsedCallee(...expression.arguments.map((arg) => __privateGet(this, _parseExpression).call(this, arg, scope)));
-        case "ConditionalExpression":
-          return __privateGet(this, _parseExpression).call(this, expression.test, scope) ? __privateGet(this, _parseExpression).call(this, expression.consequent, scope) : __privateGet(this, _parseExpression).call(this, expression.alternate, scope);
-        case "ExpressionStatement":
-          return __privateGet(this, _parseExpression).call(this, expression.expression, scope);
-        case "Identifier":
-          if (expression.name === "Infinity")
-            return Infinity;
-          if (expression.name === "-Infinity")
-            return -Infinity;
-          if (expression.name === "NaN")
-            return NaN;
-          if (scope && expression.name in scope) {
-            return handleNaN(scope[expression.name]);
-          }
-          return handleNaN((this.props.bindings || {})[expression.name]);
-        case "Literal":
-          return expression.value;
-        case "LogicalExpression":
-          const left = __privateGet(this, _parseExpression).call(this, expression.left, scope);
-          if (expression.operator === "||" && left)
-            return left;
-          if (expression.operator === "&&" && left || expression.operator === "||" && !left) {
-            return __privateGet(this, _parseExpression).call(this, expression.right, scope);
-          }
-          return false;
-        case "MemberExpression":
-          return __privateGet(this, _parseMemberExpression).call(this, expression, scope);
-        case "ChainExpression":
-          return __privateGet(this, _parseChainExpression).call(this, expression, scope);
-        case "ObjectExpression":
-          const object = {};
-          expression.properties.forEach((prop) => {
-            object[prop.key.name || prop.key.value] = __privateGet(this, _parseExpression).call(this, prop.value, scope);
-          });
-          return object;
-        case "TemplateElement":
-          return expression.value.cooked;
-        case "TemplateLiteral":
-          return [...expression.expressions, ...expression.quasis].sort((a, b) => {
-            if (a.start < b.start)
-              return -1;
-            return 1;
-          }).map((item) => __privateGet(this, _parseExpression).call(this, item, scope)).join("");
-        case "UnaryExpression":
-          const unaryValue = __privateGet(this, _parseExpression).call(this, expression.argument, scope);
-          switch (expression.operator) {
-            case "+":
-              return +unaryValue;
-            case "-":
-              return -unaryValue;
-            case "!":
-              return !unaryValue;
-          }
-          return;
-        case "ArrowFunctionExpression":
-          if (expression.async || expression.generator) {
-            (_b = (_a = this.props).onError) == null ? void 0 : _b.call(_a, new Error("Async and generator arrow functions are not supported."));
-          }
-          return (...args) => {
-            const functionScope = { ...scope };
-            expression.params.forEach((param, idx) => {
-              functionScope[param.name] = args[idx];
-            });
-            return __privateGet(this, _parseExpression).call(this, expression.body, functionScope);
-          };
-        default:
-          this.props.onError(new Error(`The expression type '${expression.type}' is not supported.`));
+          this.props.onError(new Error(`The expression '${expression.callee}' could not be resolved, resulting in an undefined return value.`));
           return;
-      }
-    });
-    __privateAdd(this, _parseChainExpression, (expression, scope) => {
-      try {
-        return __privateGet(this, _parseExpression).call(this, expression.expression, scope);
-      } catch (error) {
-        if (error instanceof NullishShortCircuit)
-          return;
-        throw error;
-      }
-    });
-    __privateAdd(this, _parseMemberExpression, (expression, scope) => {
-      const object = __privateGet(this, _parseExpression).call(this, expression.object, scope);
-      let property;
-      if (expression.computed) {
-        property = __privateGet(this, _parseExpression).call(this, expression.property, scope);
-      } else if (expression.property.type === "Identifier") {
-        property = expression.property.name;
-      } else {
-        this.props.onError(new Error("Only simple MemberExpressions are supported."));
-        return;
-      }
-      if (object === null || object === void 0) {
-        if (expression.optional)
-          throw new NullishShortCircuit();
-      }
-      let member;
-      try {
-        member = object[property];
-      } catch {
-        this.props.onError(new Error(`The property '${property}' could not be resolved on the object '${object}'.`));
-        return;
-      }
-      if (typeof member === "function")
-        return member.bind(object);
-      return member;
-    });
-    __privateAdd(this, _parseName, (element) => {
-      if (element.type === "JSXIdentifier") {
-        return element.name;
-      }
-      return `${__privateGet(this, _parseName).call(this, element.object)}.${__privateGet(this, _parseName).call(this, element.property)}`;
-    });
-    __privateAdd(this, _parseElement, (element, scope) => {
-      const { allowUnknownElements, components, componentsOnly, onError } = this.props;
-      const { children: childNodes = [] } = element;
-      const openingTag = element.type === "JSXElement" ? element.openingElement : element.openingFragment;
-      const { attributes = [] } = openingTag;
-      const name = element.type === "JSXElement" ? __privateGet(this, _parseName).call(this, openingTag.name) : "";
-      const blacklistedAttrs = (this.props.blacklistedAttrs || []).map((attr) => attr instanceof RegExp ? attr : new RegExp(attr, "i"));
-      const blacklistedTags = (this.props.blacklistedTags || []).map((tag) => tag.trim().toLowerCase()).filter(Boolean);
-      if (/^(html|head|body)$/i.test(name)) {
-        return childNodes.map((c) => __privateGet(this, _parseElement).call(this, c, scope));
-      }
-      const tagName = name.trim().toLowerCase();
-      if (blacklistedTags.indexOf(tagName) !== -1) {
-        onError(new Error(`The tag <${name}> is blacklisted, and will not be rendered.`));
-        return null;
-      }
-      if (name !== "" && !resolvePath(components, name)) {
-        if (componentsOnly) {
-          onError(new Error(`The component <${name}> is unrecognized, and will not be rendered.`));
-          return this.props.renderUnrecognized(name);
-        }
-        if (!allowUnknownElements && document.createElement(name) instanceof HTMLUnknownElement) {
-          onError(new Error(`The tag <${name}> is unrecognized in this browser, and will not be rendered.`));
-          return this.props.renderUnrecognized(name);
-        }
-      }
-      let children;
-      let component = element.type === "JSXElement" ? resolvePath(components, name) : Fragment;
-      if (component || canHaveChildren(name)) {
-        children = childNodes.map((node) => __privateGet(this, _parseExpression).call(this, node, scope));
-        if (name.includes(".")) {
-          const nameParts = name.split(".");
-          const componentPath = nameParts.reduce((acc, part) => acc ? acc[part] : components == null ? void 0 : components[part], null);
-          if (componentPath) {
-            component = componentPath;
-          }
         }
-        if (!component && !canHaveWhitespace(name)) {
-          children = children.filter((child) => typeof child !== "string" || !/^\s*$/.test(child));
+        return parsedCallee(...expression.arguments.map((arg) => this.#parseExpression(arg, scope)));
+      case "ConditionalExpression":
+        return this.#parseExpression(expression.test, scope) ? this.#parseExpression(expression.consequent, scope) : this.#parseExpression(expression.alternate, scope);
+      case "ExpressionStatement":
+        return this.#parseExpression(expression.expression, scope);
+      case "Identifier":
+        if (expression.name === "Infinity")
+          return Infinity;
+        if (expression.name === "-Infinity")
+          return -Infinity;
+        if (expression.name === "NaN")
+          return NaN;
+        if (scope && expression.name in scope) {
+          return handleNaN(scope[expression.name]);
+        }
+        return handleNaN((this.props.bindings || {})[expression.name]);
+      case "Literal":
+        return expression.value;
+      case "LogicalExpression":
+        const left = this.#parseExpression(expression.left, scope);
+        if (expression.operator === "||" && left)
+          return left;
+        if (expression.operator === "&&" && left || expression.operator === "||" && !left) {
+          return this.#parseExpression(expression.right, scope);
         }
-        const childFn = children.find((child) => typeof child === "function");
-        if (children.length === 0) {
-          children = void 0;
-        } else if (childFn) {
-          children = childFn;
-        } else if (children.length === 1) {
-          [children] = children;
-        } else if (children.length > 1 && !this.props.disableKeyGeneration) {
-          children = children.map((child, key) => (child == null ? void 0 : child.type) && !(child == null ? void 0 : child.key) ? { ...child, key: child.key || key } : child);
+        return false;
+      case "MemberExpression":
+        return this.#parseMemberExpression(expression, scope);
+      case "ChainExpression":
+        return this.#parseChainExpression(expression, scope);
+      case "ObjectExpression":
+        const object = {};
+        expression.properties.forEach((prop) => {
+          object[prop.key.name || prop.key.value] = this.#parseExpression(prop.value, scope);
+        });
+        return object;
+      case "TemplateElement":
+        return expression.value.cooked;
+      case "TemplateLiteral":
+        return [...expression.expressions, ...expression.quasis].sort((a, b) => {
+          if (a.start < b.start)
+            return -1;
+          return 1;
+        }).map((item) => this.#parseExpression(item, scope)).join("");
+      case "UnaryExpression":
+        const unaryValue = this.#parseExpression(expression.argument, scope);
+        switch (expression.operator) {
+          case "+":
+            return +unaryValue;
+          case "-":
+            return -unaryValue;
+          case "!":
+            return !unaryValue;
         }
-      }
-      const props = {
-        key: this.props.disableKeyGeneration ? void 0 : randomHash()
-      };
-      attributes.forEach((expr) => {
-        if (expr.type === "JSXAttribute") {
-          const rawName = expr.name.name;
-          const attributeName = attributeNames_default[rawName] || rawName;
-          const value = __privateGet(this, _parseExpression).call(this, expr, scope);
-          const matches = blacklistedAttrs.filter((re) => re.test(attributeName));
-          if (matches.length === 0) {
-            props[attributeName] = value;
-          }
-        } else if (expr.type === "JSXSpreadAttribute" && expr.argument.type === "Identifier" || expr.argument.type === "MemberExpression") {
-          const value = __privateGet(this, _parseExpression).call(this, expr.argument, scope);
-          if (typeof value === "object") {
-            Object.keys(value).forEach((rawName) => {
-              const attributeName = attributeNames_default[rawName] || rawName;
-              const matches = blacklistedAttrs.filter((re) => re.test(attributeName));
-              if (matches.length === 0) {
-                props[attributeName] = value[rawName];
-              }
-            });
-          }
+        return;
+      case "ArrowFunctionExpression":
+        if (expression.async || expression.generator) {
+          this.props.onError?.(new Error("Async and generator arrow functions are not supported."));
+        }
+        return (...args) => {
+          const functionScope = { ...scope };
+          expression.params.forEach((param, idx) => {
+            functionScope[param.name] = args[idx];
+          });
+          return this.#parseExpression(expression.body, functionScope);
+        };
+      default:
+        this.props.onError(new Error(`The expression type '${expression.type}' is not supported.`));
+        return;
+    }
+  };
+  #parseChainExpression = (expression, scope) => {
+    try {
+      return this.#parseExpression(expression.expression, scope);
+    } catch (error) {
+      if (error instanceof NullishShortCircuit)
+        return;
+      throw error;
+    }
+  };
+  #parseMemberExpression = (expression, scope) => {
+    const object = this.#parseExpression(expression.object, scope);
+    let property;
+    if (expression.computed) {
+      property = this.#parseExpression(expression.property, scope);
+    } else if (expression.property.type === "Identifier") {
+      property = expression.property.name;
+    } else {
+      this.props.onError(new Error("Only simple MemberExpressions are supported."));
+      return;
+    }
+    if (object === null || object === void 0) {
+      if (expression.optional)
+        throw new NullishShortCircuit();
+    }
+    let member;
+    try {
+      member = object[property];
+    } catch {
+      this.props.onError(new Error(`The property '${property}' could not be resolved on the object '${object}'.`));
+      return;
+    }
+    if (typeof member === "function")
+      return member.bind(object);
+    return member;
+  };
+  #parseName = (element) => {
+    if (element.type === "JSXIdentifier") {
+      return element.name;
+    }
+    return `${this.#parseName(element.object)}.${this.#parseName(element.property)}`;
+  };
+  #parseElement = (element, scope) => {
+    const { allowUnknownElements, components, componentsOnly, onError } = this.props;
+    const { children: childNodes = [] } = element;
+    const openingTag = element.type === "JSXElement" ? element.openingElement : element.openingFragment;
+    const { attributes = [] } = openingTag;
+    const name = element.type === "JSXElement" ? this.#parseName(openingTag.name) : "";
+    const blacklistedAttrs = (this.props.blacklistedAttrs || []).map((attr) => attr instanceof RegExp ? attr : new RegExp(attr, "i"));
+    const blacklistedTags = (this.props.blacklistedTags || []).map((tag) => tag.trim().toLowerCase()).filter(Boolean);
+    if (/^(html|head|body)$/i.test(name)) {
+      return childNodes.map((c) => this.#parseElement(c, scope));
+    }
+    const tagName = name.trim().toLowerCase();
+    if (blacklistedTags.indexOf(tagName) !== -1) {
+      onError(new Error(`The tag <${name}> is blacklisted, and will not be rendered.`));
+      return null;
+    }
+    if (name !== "" && !resolvePath(components, name)) {
+      if (componentsOnly) {
+        onError(new Error(`The component <${name}> is unrecognized, and will not be rendered.`));
+        return this.props.renderUnrecognized(name);
+      }
+      if (!allowUnknownElements && document.createElement(name) instanceof HTMLUnknownElement) {
+        onError(new Error(`The tag <${name}> is unrecognized in this browser, and will not be rendered.`));
+        return this.props.renderUnrecognized(name);
+      }
+    }
+    let children;
+    let component = element.type === "JSXElement" ? resolvePath(components, name) : Fragment;
+    if (component || canHaveChildren(name)) {
+      children = childNodes.map((node) => this.#parseExpression(node, scope));
+      if (name.includes(".")) {
+        const nameParts = name.split(".");
+        const componentPath = nameParts.reduce((acc, part) => acc ? acc[part] : components?.[part], null);
+        if (componentPath) {
+          component = componentPath;
+        }
+      }
+      if (!component && !canHaveWhitespace(name)) {
+        children = children.filter((child) => typeof child !== "string" || !/^\s*$/.test(child));
+      }
+      const childFn = children.find((child) => typeof child === "function");
+      if (children.length === 0) {
+        children = void 0;
+      } else if (childFn) {
+        children = childFn;
+      } else if (children.length === 1) {
+        [children] = children;
+      } else if (children.length > 1 && !this.props.disableKeyGeneration) {
+        children = children.map((child, key) => child?.type && !child?.key ? { ...child, key: child.key || key } : child);
+      }
+    }
+    const props = {
+      key: this.props.disableKeyGeneration ? void 0 : randomHash()
+    };
+    attributes.forEach((expr) => {
+      if (expr.type === "JSXAttribute") {
+        const rawName = expr.name.name;
+        const attributeName = attributeNames_default[rawName] || rawName;
+        const value = this.#parseExpression(expr, scope);
+        const matches = blacklistedAttrs.filter((re) => re.test(attributeName));
+        if (matches.length === 0) {
+          props[attributeName] = value;
+        }
+      } else if (expr.type === "JSXSpreadAttribute" && expr.argument.type === "Identifier" || expr.argument.type === "MemberExpression") {
+        const value = this.#parseExpression(expr.argument, scope);
+        if (typeof value === "object") {
+          Object.keys(value).forEach((rawName) => {
+            const attributeName = attributeNames_default[rawName] || rawName;
+            const matches = blacklistedAttrs.filter((re) => re.test(attributeName));
+            if (matches.length === 0) {
+              props[attributeName] = value[rawName];
+            }
+          });
         }
-      });
-      if (typeof props.style === "string") {
-        props.style = parseStyle(props.style);
-      }
-      const lowerName = name.toLowerCase();
-      if (lowerName === "option") {
-        children = children.props.children;
       }
-      return React__default.createElement(component || lowerName, props, children);
     });
-  }
+    if (typeof props.style === "string") {
+      props.style = parseStyle(props.style);
+    }
+    const lowerName = name.toLowerCase();
+    if (lowerName === "option") {
+      children = children.props.children;
+    }
+    return React__default.createElement(component || lowerName, props, children);
+  };
   render() {
     const jsx = (this.props.jsx || "").trim().replace(/<!DOCTYPE([^>]*)>/g, "");
-    this.ParsedChildren = __privateGet(this, _parseJSX).call(this, jsx);
+    this.ParsedChildren = this.#parseJSX(jsx);
     const className = [.../* @__PURE__ */ new Set(["jsx-parser", ...String(this.props.className).split(" ")])].filter(Boolean).join(" ");
     return this.props.renderInWrapper ? /* @__PURE__ */ React__default.createElement("div", {
       className
     }, this.ParsedChildren) : this.ParsedChildren;
   }
 }
-_parseJSX = new WeakMap();
-_parseExpression = new WeakMap();
-_parseChainExpression = new WeakMap();
-_parseMemberExpression = new WeakMap();
-_parseName = new WeakMap();
-_parseElement = new WeakMap();
-__publicField(JsxParser, "displayName", "JsxParser");
-__publicField(JsxParser, "defaultProps", {
-  allowUnknownElements: true,
-  autoCloseVoidElements: false,
-  bindings: {},
-  blacklistedAttrs: [/^on.+/i],
-  blacklistedTags: ["script"],
-  className: "",
-  components: {},
-  componentsOnly: false,
-  disableFragments: false,
-  disableKeyGeneration: false,
-  jsx: "",
-  onError: () => {
-  },
-  showWarnings: false,
-  renderError: void 0,
-  renderInWrapper: true,
-  renderUnrecognized: () => null
-});
 var source_default = JsxParser;
 export {
   source_default as a,