armtek-uikit-react 1.0.268 → 1.0.270

package/lib/cjs/node_modules/side-channel-list/index.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../object-inspect/index.cjs");
+const type = require("../es-errors/type.cjs");
+var sideChannelList;
+var hasRequiredSideChannelList;
+function requireSideChannelList() {
+  if (hasRequiredSideChannelList) return sideChannelList;
+  hasRequiredSideChannelList = 1;
+  var inspect = /* @__PURE__ */ index.__require();
+  var $TypeError = /* @__PURE__ */ type.__require();
+  var listGetNode = function(list, key, isDelete) {
+    var prev = list;
+    var curr;
+    for (; (curr = prev.next) != null; prev = curr) {
+      if (curr.key === key) {
+        prev.next = curr.next;
+        if (!isDelete) {
+          curr.next = /** @type {NonNullable<typeof list.next>} */
+          list.next;
+          list.next = curr;
+        }
+        return curr;
+      }
+    }
+  };
+  var listGet = function(objects, key) {
+    if (!objects) {
+      return void 0;
+    }
+    var node = listGetNode(objects, key);
+    return node && node.value;
+  };
+  var listSet = function(objects, key, value) {
+    var node = listGetNode(objects, key);
+    if (node) {
+      node.value = value;
+    } else {
+      objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */
+      {
+        // eslint-disable-line no-param-reassign, no-extra-parens
+        key,
+        next: objects.next,
+        value
+      };
+    }
+  };
+  var listHas = function(objects, key) {
+    if (!objects) {
+      return false;
+    }
+    return !!listGetNode(objects, key);
+  };
+  var listDelete = function(objects, key) {
+    if (objects) {
+      return listGetNode(objects, key, true);
+    }
+  };
+  sideChannelList = function getSideChannelList() {
+    var $o;
+    var channel = {
+      assert: function(key) {
+        if (!channel.has(key)) {
+          throw new $TypeError("Side channel does not contain " + inspect(key));
+        }
+      },
+      "delete": function(key) {
+        var root = $o && $o.next;
+        var deletedNode = listDelete($o, key);
+        if (deletedNode && root && root === deletedNode) {
+          $o = void 0;
+        }
+        return !!deletedNode;
+      },
+      get: function(key) {
+        return listGet($o, key);
+      },
+      has: function(key) {
+        return listHas($o, key);
+      },
+      set: function(key, value) {
+        if (!$o) {
+          $o = {
+            next: void 0
+          };
+        }
+        listSet(
+          /** @type {NonNullable<typeof $o>} */
+          $o,
+          key,
+          value
+        );
+      }
+    };
+    return channel;
+  };
+  return sideChannelList;
+}
+exports.__require = requireSideChannelList;

package/lib/cjs/node_modules/side-channel-map/index.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../get-intrinsic/index.cjs");
+const index$1 = require("../call-bound/index.cjs");
+const index$2 = require("../object-inspect/index.cjs");
+const type = require("../es-errors/type.cjs");
+var sideChannelMap;
+var hasRequiredSideChannelMap;
+function requireSideChannelMap() {
+  if (hasRequiredSideChannelMap) return sideChannelMap;
+  hasRequiredSideChannelMap = 1;
+  var GetIntrinsic = /* @__PURE__ */ index.__require();
+  var callBound = /* @__PURE__ */ index$1.__require();
+  var inspect = /* @__PURE__ */ index$2.__require();
+  var $TypeError = /* @__PURE__ */ type.__require();
+  var $Map = GetIntrinsic("%Map%", true);
+  var $mapGet = callBound("Map.prototype.get", true);
+  var $mapSet = callBound("Map.prototype.set", true);
+  var $mapHas = callBound("Map.prototype.has", true);
+  var $mapDelete = callBound("Map.prototype.delete", true);
+  var $mapSize = callBound("Map.prototype.size", true);
+  sideChannelMap = !!$Map && /** @type {Exclude<import('.'), false>} */
+  function getSideChannelMap() {
+    var $m;
+    var channel = {
+      assert: function(key) {
+        if (!channel.has(key)) {
+          throw new $TypeError("Side channel does not contain " + inspect(key));
+        }
+      },
+      "delete": function(key) {
+        if ($m) {
+          var result = $mapDelete($m, key);
+          if ($mapSize($m) === 0) {
+            $m = void 0;
+          }
+          return result;
+        }
+        return false;
+      },
+      get: function(key) {
+        if ($m) {
+          return $mapGet($m, key);
+        }
+      },
+      has: function(key) {
+        if ($m) {
+          return $mapHas($m, key);
+        }
+        return false;
+      },
+      set: function(key, value) {
+        if (!$m) {
+          $m = new $Map();
+        }
+        $mapSet($m, key, value);
+      }
+    };
+    return channel;
+  };
+  return sideChannelMap;
+}
+exports.__require = requireSideChannelMap;

package/lib/cjs/node_modules/side-channel-weakmap/index.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../get-intrinsic/index.cjs");
+const index$2 = require("../call-bound/index.cjs");
+const index$3 = require("../object-inspect/index.cjs");
+const index = require("../side-channel-map/index.cjs");
+const type = require("../es-errors/type.cjs");
+var sideChannelWeakmap;
+var hasRequiredSideChannelWeakmap;
+function requireSideChannelWeakmap() {
+  if (hasRequiredSideChannelWeakmap) return sideChannelWeakmap;
+  hasRequiredSideChannelWeakmap = 1;
+  var GetIntrinsic = /* @__PURE__ */ index$1.__require();
+  var callBound = /* @__PURE__ */ index$2.__require();
+  var inspect = /* @__PURE__ */ index$3.__require();
+  var getSideChannelMap = index.__require();
+  var $TypeError = /* @__PURE__ */ type.__require();
+  var $WeakMap = GetIntrinsic("%WeakMap%", true);
+  var $weakMapGet = callBound("WeakMap.prototype.get", true);
+  var $weakMapSet = callBound("WeakMap.prototype.set", true);
+  var $weakMapHas = callBound("WeakMap.prototype.has", true);
+  var $weakMapDelete = callBound("WeakMap.prototype.delete", true);
+  sideChannelWeakmap = $WeakMap ? (
+    /** @type {Exclude<import('.'), false>} */
+    function getSideChannelWeakMap() {
+      var $wm;
+      var $m;
+      var channel = {
+        assert: function(key) {
+          if (!channel.has(key)) {
+            throw new $TypeError("Side channel does not contain " + inspect(key));
+          }
+        },
+        "delete": function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapDelete($wm, key);
+            }
+          } else if (getSideChannelMap) {
+            if ($m) {
+              return $m["delete"](key);
+            }
+          }
+          return false;
+        },
+        get: function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapGet($wm, key);
+            }
+          }
+          return $m && $m.get(key);
+        },
+        has: function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapHas($wm, key);
+            }
+          }
+          return !!$m && $m.has(key);
+        },
+        set: function(key, value) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if (!$wm) {
+              $wm = new $WeakMap();
+            }
+            $weakMapSet($wm, key, value);
+          } else if (getSideChannelMap) {
+            if (!$m) {
+              $m = getSideChannelMap();
+            }
+            $m.set(key, value);
+          }
+        }
+      };
+      return channel;
+    }
+  ) : getSideChannelMap;
+  return sideChannelWeakmap;
+}
+exports.__require = requireSideChannelWeakmap;

package/lib/cjs/node_modules/stop-iteration-iterator/index.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../internal-slot/index.cjs");
+const syntax = require("../es-errors/syntax.cjs");
+var stopIterationIterator;
+var hasRequiredStopIterationIterator;
+function requireStopIterationIterator() {
+  if (hasRequiredStopIterationIterator) return stopIterationIterator;
+  hasRequiredStopIterationIterator = 1;
+  var SLOT = index.__require();
+  var $SyntaxError = /* @__PURE__ */ syntax.__require();
+  var $StopIteration = typeof StopIteration === "object" ? StopIteration : null;
+  stopIterationIterator = function getStopIterationIterator(origIterator) {
+    if (!$StopIteration) {
+      throw new $SyntaxError("this environment lacks StopIteration");
+    }
+    SLOT.set(origIterator, "[[Done]]", false);
+    var siIterator = {
+      next: (
+        /** @type {() => IteratorResult<T>} */
+        function next() {
+          var iterator = (
+            /** @type {typeof origIterator} */
+            SLOT.get(this, "[[Iterator]]")
+          );
+          var done = !!SLOT.get(iterator, "[[Done]]");
+          try {
+            return {
+              done,
+              // eslint-disable-next-line no-extra-parens
+              value: done ? void 0 : (
+                /** @type {T} */
+                iterator.next()
+              )
+            };
+          } catch (e) {
+            SLOT.set(iterator, "[[Done]]", true);
+            if (e !== $StopIteration) {
+              throw e;
+            }
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+        }
+      )
+    };
+    SLOT.set(siIterator, "[[Iterator]]", origIterator);
+    return siIterator;
+  };
+  return stopIterationIterator;
+}
+exports.__require = requireStopIterationIterator;

package/lib/cjs/node_modules/which-boxed-primitive/index.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../is-string/index.cjs");
+const index$1 = require("../is-number-object/index.cjs");
+const index$2 = require("../is-boolean-object/index.cjs");
+const index$3 = require("../is-symbol/index.cjs");
+const index$4 = require("../is-bigint/index.cjs");
+var whichBoxedPrimitive;
+var hasRequiredWhichBoxedPrimitive;
+function requireWhichBoxedPrimitive() {
+  if (hasRequiredWhichBoxedPrimitive) return whichBoxedPrimitive;
+  hasRequiredWhichBoxedPrimitive = 1;
+  var isString = index.__require();
+  var isNumber = index$1.__require();
+  var isBoolean = index$2.__require();
+  var isSymbol = index$3.__require();
+  var isBigInt = index$4.__require();
+  whichBoxedPrimitive = function whichBoxedPrimitive2(value) {
+    if (value == null || typeof value !== "object" && typeof value !== "function") {
+      return null;
+    }
+    if (isString(value)) {
+      return "String";
+    }
+    if (isNumber(value)) {
+      return "Number";
+    }
+    if (isBoolean(value)) {
+      return "Boolean";
+    }
+    if (isSymbol(value)) {
+      return "Symbol";
+    }
+    if (isBigInt(value)) {
+      return "BigInt";
+    }
+  };
+  return whichBoxedPrimitive;
+}
+exports.__require = requireWhichBoxedPrimitive;

package/lib/cjs/node_modules/which-collection/index.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../is-map/index.cjs");
+const index$2 = require("../is-set/index.cjs");
+const index = require("../is-weakmap/index.cjs");
+const index$3 = require("../is-weakset/index.cjs");
+var whichCollection;
+var hasRequiredWhichCollection;
+function requireWhichCollection() {
+  if (hasRequiredWhichCollection) return whichCollection;
+  hasRequiredWhichCollection = 1;
+  var isMap = /* @__PURE__ */ index$1.__require();
+  var isSet = /* @__PURE__ */ index$2.__require();
+  var isWeakMap = index.__require();
+  var isWeakSet = /* @__PURE__ */ index$3.__require();
+  whichCollection = function whichCollection2(value) {
+    if (value && typeof value === "object") {
+      if (isMap(value)) {
+        return "Map";
+      }
+      if (isSet(value)) {
+        return "Set";
+      }
+      if (isWeakMap(value)) {
+        return "WeakMap";
+      }
+      if (isWeakSet(value)) {
+        return "WeakSet";
+      }
+    }
+    return false;
+  };
+  return whichCollection;
+}
+exports.__require = requireWhichCollection;

package/lib/cjs/node_modules/which-typed-array/index.cjs

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _commonjsHelpers = require("../../_virtual/_commonjsHelpers.cjs");
+const index = require("../for-each/index.cjs");
+const index$4 = require("../available-typed-arrays/index.cjs");
+const index$1 = require("../call-bind/index.cjs");
+const index$3 = require("../call-bound/index.cjs");
+const index$5 = require("../gopd/index.cjs");
+const index$2 = require("../get-proto/index.cjs");
+const shams = require("../has-tostringtag/shams.cjs");
+var whichTypedArray;
+var hasRequiredWhichTypedArray;
+function requireWhichTypedArray() {
+  if (hasRequiredWhichTypedArray) return whichTypedArray;
+  hasRequiredWhichTypedArray = 1;
+  var forEach = index.__require();
+  var availableTypedArrays = /* @__PURE__ */ index$4.__require();
+  var callBind = index$1.__require();
+  var callBound = /* @__PURE__ */ index$3.__require();
+  var gOPD = /* @__PURE__ */ index$5.__require();
+  var getProto = index$2.__require();
+  var $toString = callBound("Object.prototype.toString");
+  var hasToStringTag = shams.__require()();
+  var g = typeof globalThis === "undefined" ? _commonjsHelpers.commonjsGlobal : globalThis;
+  var typedArrays = availableTypedArrays();
+  var $slice = callBound("String.prototype.slice");
+  var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
+    for (var i = 0; i < array.length; i += 1) {
+      if (array[i] === value) {
+        return i;
+      }
+    }
+    return -1;
+  };
+  var cache = { __proto__: null };
+  if (hasToStringTag && gOPD && getProto) {
+    forEach(typedArrays, function(typedArray) {
+      var arr = new g[typedArray]();
+      if (Symbol.toStringTag in arr && getProto) {
+        var proto = getProto(arr);
+        var descriptor = gOPD(proto, Symbol.toStringTag);
+        if (!descriptor && proto) {
+          var superProto = getProto(proto);
+          descriptor = gOPD(superProto, Symbol.toStringTag);
+        }
+        cache["$" + typedArray] = callBind(descriptor.get);
+      }
+    });
+  } else {
+    forEach(typedArrays, function(typedArray) {
+      var arr = new g[typedArray]();
+      var fn = arr.slice || arr.set;
+      if (fn) {
+        cache[
+          /** @type {`$${import('.').TypedArrayName}`} */
+          "$" + typedArray
+        ] = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */
+        // @ts-expect-error TODO FIXME
+        callBind(fn);
+      }
+    });
+  }
+  var tryTypedArrays = function tryAllTypedArrays(value) {
+    var found = false;
+    forEach(
+      /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
+      cache,
+      /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+      function(getter, typedArray) {
+        if (!found) {
+          try {
+            if ("$" + getter(value) === typedArray) {
+              found = /** @type {import('.').TypedArrayName} */
+              $slice(typedArray, 1);
+            }
+          } catch (e) {
+          }
+        }
+      }
+    );
+    return found;
+  };
+  var trySlices = function tryAllSlices(value) {
+    var found = false;
+    forEach(
+      /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
+      cache,
+      /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+      function(getter, name) {
+        if (!found) {
+          try {
+            getter(value);
+            found = /** @type {import('.').TypedArrayName} */
+            $slice(name, 1);
+          } catch (e) {
+          }
+        }
+      }
+    );
+    return found;
+  };
+  whichTypedArray = function whichTypedArray2(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    if (!hasToStringTag) {
+      var tag = $slice($toString(value), 8, -1);
+      if ($indexOf(typedArrays, tag) > -1) {
+        return tag;
+      }
+      if (tag !== "Object") {
+        return false;
+      }
+      return trySlices(value);
+    }
+    if (!gOPD) {
+      return null;
+    }
+    return tryTypedArrays(value);
+  };
+  return whichTypedArray;
+}
+exports.__require = requireWhichTypedArray;

package/lib/cjs/ui/Accordion/Accordion.cjs

@@ -8,6 +8,7 @@ const ui_ButtonIcon_ButtonIcon = require("../ButtonIcon/ButtonIcon.cjs");
 const ui_Accordion_Accordion_classes = require("./Accordion.classes.cjs");
 require("../Icon/Icon.cjs");
 const ui_Icon_Mi = require("../Icon/Mi.cjs");
+require("../Icon/Mis.cjs");
 const ui_Accordion_AccordionHeading = require("./AccordionHeading.cjs");
 const Accordion = (props) => {
   let {

package/lib/cjs/ui/Avatar/Avatar.cjs

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
 const clsx = require("clsx");
 const getLetters = (name) => {
   let nameParts = name.split(" ");
   return nameParts[0].split("")[0] + (nameParts[1] ? nameParts[1].split("")[0] : "");
 };
-const Avatar = (props) => {
+const Avatar = React.forwardRef((props, ref) => {
   const {
     variant = "roundedXl",
     photo,
@@ -22,13 +23,13 @@ const Avatar = (props) => {
   let displayIcon = icon;
   if (!props.icon && !props.name && !photo) displayIcon = "person";
   let content = photo ? /* @__PURE__ */ jsxRuntime.jsx("img", { src: photo, className: "arm-avatar__img", alt: props.name, title: props.name }) : props.name ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "arm-avatar__name", children: getLetters(props.name) }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: clsx("arm-avatar__icon", "material_icon_solid"), children: displayIcon });
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { ...divProps, className: clsx("arm-avatar", className, "arm-avatar_" + variant, {
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { ref, ...divProps, className: clsx("arm-avatar", className, "arm-avatar_" + variant, {
     ["arm-avatar__photo"]: !!photo,
     ["arm-avatar__icon"]: !!displayIcon
   }, ["arm-avatar_" + size]), "data-testid": "avatar", children: [
     /* @__PURE__ */ jsxRuntime.jsx("div", { className: "arm-avatar__inner", children: href ? /* @__PURE__ */ jsxRuntime.jsx("a", { href, ...linkProps, className: "arm-avatar__text", children: content }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "arm-avatar__text", children: content }) }),
     status && /* @__PURE__ */ jsxRuntime.jsx("span", { className: clsx("arm-avatar__status", ["arm-avatar__status_" + status]) })
   ] }) });
-};
+});
 exports.default = Avatar;
 exports.getLetters = getLetters;

package/lib/cjs/ui/Avatar/Avatar.d.ts

@@ -11,5 +11,14 @@ export type AvatarProps = {
     variant?: 'square' | 'rounded' | 'roundedXl';
 } & ComponentPropsWithoutRef<'div'>;
 export declare const getLetters: (name: string) => string;
-declare const Avatar: (props: AvatarProps) => import("react/jsx-runtime").JSX.Element;
+declare const Avatar: import("react").ForwardRefExoticComponent<{
+    photo?: string;
+    name?: string;
+    href?: string;
+    linkProps?: HTMLAttributes<HTMLAnchorElement>;
+    icon?: string;
+    size?: Exclude<SizeType, "extraLarge">;
+    status?: Exclude<ColorStatusType, "info">;
+    variant?: "square" | "rounded" | "roundedXl";
+} & Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
 export default Avatar;

package/lib/cjs/ui/BackDrop/BackDrop.cjs

@@ -3,7 +3,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 const jsxRuntime = require("react/jsx-runtime");
 const lib_helpers_genericForwardRef = require("../../lib/helpers/genericForwardRef.cjs");
 const React = require("react");
-const reactDom = require("react-dom");
+const ReactDOM = require("react-dom");
 const ui_BackDrop_BackDropBase = require("./BackDropBase.cjs");
 const BackDrop = (props, ref) => {
   const {
@@ -11,7 +11,7 @@ const BackDrop = (props, ref) => {
     ...backDropProps
   } = props;
   const childrenProp = React.isValidElement(children) ? children : /* @__PURE__ */ jsxRuntime.jsx("span", { children });
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: reactDom.createPortal(/* @__PURE__ */ jsxRuntime.jsx(ui_BackDrop_BackDropBase.BackDropBase, { ...backDropProps, ref, children: childrenProp }), document.body) });
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: ReactDOM.createPortal(/* @__PURE__ */ jsxRuntime.jsx(ui_BackDrop_BackDropBase.BackDropBase, { ...backDropProps, ref, children: childrenProp }), document.body) });
 };
 const BackDrop$1 = lib_helpers_genericForwardRef.fixedForwardRef(BackDrop);
 exports.default = BackDrop$1;

package/lib/cjs/ui/Button/Button.d.ts

@@ -35,5 +35,5 @@ declare const _default: <T extends ElementType = "button">(props: {
     as?: T | undefined;
 } & {
     [dataAttibute: `data-${string}`]: string;
-} & Omit<import("react").PropsWithoutRef<import("react").ComponentProps<T>>, "color" | "size" | "disabled" | "radius" | "as" | "group" | `data-${string}` | "variant" | "startAdornment" | "endAdornment" | "asIcon" | "theme" | "fullWidth" | "disablestyles"> & import("react").RefAttributes<any>) => JSX.Element;
+} & Omit<import("react").PropsWithoutRef<import("react").ComponentProps<T>>, `data-${string}` | "color" | "group" | "size" | "variant" | "startAdornment" | "endAdornment" | "radius" | "asIcon" | "theme" | "fullWidth" | "disablestyles" | "disabled" | "as"> & import("react").RefAttributes<any>) => JSX.Element;
 export default _default;

package/lib/cjs/ui/ButtonIcon/ButtonIcon.cjs

@@ -5,13 +5,15 @@ const ui_Button_Button = require("../Button/Button.cjs");
 const clsx = require("clsx");
 const lib_helpers_genericForwardRef = require("../../lib/helpers/genericForwardRef.cjs");
 const ui_Icon_Icon = require("../Icon/Icon.cjs");
-require("react");
-require("react-dom");
-require("@popperjs/core");
+require("../Icon/Mi.cjs");
+require("../Icon/Mis.cjs");
 function ButtonIcon(props, ref) {
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(ui_Button_Button.default, { color: "neutral", variant: "transparent", ...props, ref, asIcon: true, className: clsx("arm-button-icon", ["arm-button-icon_" + props.size], props.className, {
+  const hasPresetIcon = !!(props.mi || props.mis);
+  const buttonSize = props.size || "extraLarge";
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(ui_Button_Button.default, { color: "neutral", variant: "transparent", ...props, ref, asIcon: true, className: clsx("arm-button-icon", ["arm-button-icon_" + buttonSize], props.className, {
     "arm-button-icon_square": props.radius === false,
-    "border-radius": props.radius === true
+    "border-radius": props.radius === true,
+    "arm-button-icon_with-icon": hasPresetIcon
   }), children: props.mi || props.mis ? /* @__PURE__ */ jsxRuntime.jsx(ui_Icon_Icon.default, { icon: props.mi || props.mis, variant: props.mis ? "contained" : "outlined", ...props.iconProps }) : props.children }) });
 }
 const ButtonIcon$1 = lib_helpers_genericForwardRef.fixedForwardRef(ButtonIcon);

package/lib/cjs/ui/ButtonIcon/ButtonIcon.d.ts

@@ -21,5 +21,5 @@ declare const _default: <T extends ElementType = "button">(props: ButtonIconProp
     as?: T | undefined;
 } & {
     [dataAttibute: `data-${string}`]: string;
-} & Omit<import("react").PropsWithoutRef<import("react").ComponentProps<T>>, "color" | "size" | "disabled" | "radius" | "as" | "group" | `data-${string}` | "variant" | "startAdornment" | "endAdornment" | "asIcon" | "theme" | "fullWidth" | "disablestyles"> & import("react").RefAttributes<T>) => JSX.Element;
+} & Omit<import("react").PropsWithoutRef<import("react").ComponentProps<T>>, `data-${string}` | "color" | "group" | "size" | "variant" | "startAdornment" | "endAdornment" | "radius" | "asIcon" | "theme" | "fullWidth" | "disablestyles" | "disabled" | "as"> & import("react").RefAttributes<T>) => JSX.Element;
 export default _default;

package/lib/cjs/ui/Card/Card.cjs

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
 const clsx = require("clsx");
-const Card = (props) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx("div", { "data-testid": "card", ...props, className: clsx("arm-card", props.className) }) });
-};
+const Card = React.forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref, "data-testid": "card", ...props, className: clsx("arm-card", props.className) }) });
+});
 exports.default = Card;

package/lib/cjs/ui/Card/Card.d.ts

@@ -1,4 +1,4 @@
 import { HTMLAttributes } from 'react';
 export type CardProps = HTMLAttributes<HTMLDivElement>;
-declare const Card: (props: CardProps) => import("react/jsx-runtime").JSX.Element;
+declare const Card: import("react").ForwardRefExoticComponent<CardProps & import("react").RefAttributes<HTMLDivElement>>;
 export default Card;