react-magma-dom 4.16.0-next.11 → 4.16.0-next.12

package/dist/components/Checkbox/index.d.ts

@@ -77,14 +77,9 @@ export declare const HiddenLabelText: import("@emotion/styled").StyledComponent<
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType<any>;
 }, React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
-export declare const HiddenInput: import("@emotion/styled").StyledComponent<{
-    theme?: import("@emotion/react").Theme;
-    as?: React.ElementType<any>;
-}, React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, {}>;
-export declare const StyledFakeInput: import("@emotion/styled").StyledComponent<{
-    theme?: import("@emotion/react").Theme;
-    as?: React.ElementType<any>;
-} & {
+export declare const checkboxInputClassName = "magma-checkbox-input";
+export declare const HiddenInput: React.FC<React.InputHTMLAttributes<HTMLInputElement> & React.RefAttributes<HTMLInputElement>> | React.ForwardRefExoticComponent<React.InputHTMLAttributes<HTMLInputElement> & React.RefAttributes<HTMLInputElement>>;
+interface FakeInputStyleProps {
     isChecked?: boolean;
     color: string;
     disabled?: boolean;
@@ -93,6 +88,13 @@ export declare const StyledFakeInput: import("@emotion/styled").StyledComponent<
     hasError?: boolean;
     hideFocus?: boolean;
     textPosition?: CheckboxTextPosition;
-    theme?: ThemeInterface;
-}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
+    theme: ThemeInterface;
+}
+export interface StyledFakeInputProps extends FakeInputStyleProps {
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    'aria-hidden'?: React.AriaAttributes['aria-hidden'];
+}
+export declare const StyledFakeInput: React.FC<StyledFakeInputProps & React.RefAttributes<any>> | React.ForwardRefExoticComponent<StyledFakeInputProps & React.RefAttributes<any>>;
 export declare const Checkbox: React.MemoExoticComponent<React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>>;
+export {};

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { css, keyframes, ClassNames, jsx, Global } from '@emotion/react';
+import { css, keyframes, ClassNames, withEmotionCache, jsx, Global } from '@emotion/react';
 import * as React from 'react';
 import React__default, { createContext, forwardRef, useContext, createElement, useMemo, Children, cloneElement, Fragment, useState, useRef, useEffect, memo, useCallback, useLayoutEffect, isValidElement, useReducer } from 'react';
 import _styled from '@emotion/styled/base';
@@ -3845,7 +3845,7 @@ function memoize(fn) {
 }
 
 // eslint-disable-next-line no-undef
-var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
+var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|popover|popoverTarget|popoverTargetAction|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
 
 var isPropValid = /* #__PURE__ */memoize(function (prop) {
   return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
@@ -5554,6 +5554,43 @@ var CardHeading = /*#__PURE__*/forwardRef(function (props, ref) {
   }), children);
 });
 
+var isBrowser = typeof document !== 'undefined';
+var registerStyles = function registerStyles(cache, serialized, isStringTag) {
+  var className = cache.key + "-" + serialized.name;
+  if (
+  // we only need to add the styles to the registered cache if the
+  // class name could be used further down
+  // the tree but if it's a string tag, we know it won't
+  // so we don't have to add it to registered cache.
+  // this improves memory usage since we can avoid storing the whole style string
+  (isStringTag === false ||
+  // we need to always store it if we're in compat mode and
+  // in node since emotion-server relies on whether a style is in
+  // the registered cache to know whether a style is global or not
+  // also, note that this check will be dead code eliminated in the browser
+  isBrowser === false && cache.compat !== undefined) && cache.registered[className] === undefined) {
+    cache.registered[className] = serialized.styles;
+  }
+};
+var insertStyles = function insertStyles(cache, serialized, isStringTag) {
+  registerStyles(cache, serialized, isStringTag);
+  var className = cache.key + "-" + serialized.name;
+  if (cache.inserted[serialized.name] === undefined) {
+    var stylesForSSR = '';
+    var current = serialized;
+    do {
+      var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
+      if (!isBrowser && maybeStyles !== undefined) {
+        stylesForSSR += maybeStyles;
+      }
+      current = current.next;
+    } while (current !== undefined);
+    if (!isBrowser && stylesForSSR.length !== 0) {
+      return stylesForSSR;
+    }
+  }
+};
+
 var _excluded$m = ["actionable", "children", "iconPosition", "labelPosition", "size", "testId"];
 var LabelPosition;
 (function (LabelPosition) {
@@ -6231,20 +6268,92 @@ var StyledLabel$1 = function StyledLabel(_ref) {
   });
 };
 
-var _excluded$q = ["color", "containerStyle", "disabled", "errorMessage", "inputStyle", "labelStyle", "labelText", "isTextVisuallyHidden", "testId", "textPosition", "ariaLabel"];
+var _excluded$q = ["className"],
+  _excluded2$1 = ["children", "style", "aria-hidden"],
+  _excluded3 = ["color", "containerStyle", "disabled", "errorMessage", "inputStyle", "labelStyle", "labelText", "isTextVisuallyHidden", "testId", "textPosition", "ariaLabel"];
 var CheckboxTextPosition;
 (function (CheckboxTextPosition) {
   CheckboxTextPosition["left"] = "left";
   CheckboxTextPosition["right"] = "right";
 })(CheckboxTextPosition || (CheckboxTextPosition = {}));
+// Style-caching helpers for rendering checkboxes cheaply in large lists.
+var isBrowser$1 = typeof document !== 'undefined';
+// Inserts cached styles into the active Emotion cache; returns the class name
+// (and, during SSR, the inline <style> to render).
+function insertCachedStyles(cache, serialized) {
+  var rules = insertStyles(cache, serialized, true);
+  var className = cache.key + "-" + serialized.name;
+  var styles = null;
+  if (!isBrowser$1 && rules !== undefined) {
+    var serializedNames = serialized.name;
+    var next = serialized.next;
+    while (next !== undefined) {
+      serializedNames += " " + next.name;
+      next = next.next;
+    }
+    styles = createElement('style', {
+      'data-emotion': cache.key + " " + serializedNames,
+      dangerouslySetInnerHTML: {
+        __html: rules
+      },
+      nonce: cache.sheet.nonce
+    });
+  }
+  return {
+    className: className,
+    styles: styles
+  };
+}
+// Serializes styles once per unique (theme, variant) pair and caches the result.
+function createVariantStyles(build, getVariantKey, getTheme) {
+  var cacheByTheme = new WeakMap();
+  return function resolveStyles(props) {
+    var theme = getTheme(props);
+    var variants = cacheByTheme.get(theme);
+    if (!variants) {
+      variants = new Map();
+      cacheByTheme.set(theme, variants);
+    }
+    var key = getVariantKey(props);
+    var serialized = variants.get(key);
+    if (!serialized) {
+      serialized = build(props);
+      variants.set(key, serialized);
+    }
+    return serialized;
+  };
+}
+function cx() {
+  for (var _len = arguments.length, classNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    classNames[_key] = arguments[_key];
+  }
+  return classNames.filter(Boolean).join(' ');
+}
 var HiddenLabelText = /*#__PURE__*/_styled("span", {
-  target: "e1iwfc8c2",
+  target: "e1iwfc8c0",
   label: "HiddenLabelText"
-})(HiddenStyles, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AAkB2C","file":"index.tsx","sourcesContent":["import * as React from 'react';\r\nimport styled from '@emotion/styled';\r\nimport { transparentize } from 'polished';\r\nimport { CheckBoxIcon, CheckBoxOutlineBlankIcon } from 'react-magma-icons';\r\nimport { useIsInverse } from '../../inverse';\r\nimport { ThemeContext } from '../../theme/ThemeContext';\r\nimport { descriptionSuffix, omit, reactNodeToString, useGenerateId, } from '../../utils';\r\nimport { HiddenStyles } from '../../utils/UtilityStyles';\r\nimport { FormGroupContext } from '../FormGroup';\r\nimport { InputMessage } from '../Input/InputMessage';\r\nimport { DisplayInputStyles, buildDisplayInputActiveBackground, buildDisplayInputBorderColor, buildDisplayInputFocusStyles, } from '../SelectionControls/InputStyles';\r\nimport { StyledContainer } from '../SelectionControls/StyledContainer';\r\nimport { StyledLabel } from '../SelectionControls/StyledLabel';\r\nexport var CheckboxTextPosition;\r\n(function (CheckboxTextPosition) {\r\n    CheckboxTextPosition[\"left\"] = \"left\";\r\n    CheckboxTextPosition[\"right\"] = \"right\";\r\n})(CheckboxTextPosition || (CheckboxTextPosition = {}));\r\nexport const HiddenLabelText = styled.span `\n  ${HiddenStyles};\n`;\r\nexport const HiddenInput = styled.input `\n  ${HiddenStyles};\n`;\r\nfunction buildCheckIconColor(props) {\r\n    if (props.disabled) {\r\n        if (props.isInverse) {\r\n            return transparentize(0.6, props.theme.colors.neutral100);\r\n        }\r\n        return props.theme.colors.neutral300;\r\n    }\r\n    if (props.isInverse) {\r\n        return props.theme.colors.neutral100;\r\n    }\r\n    if (props.isChecked || props.isIndeterminate) {\r\n        return props.color;\r\n    }\r\n    return props.theme.colors.neutral700;\r\n}\r\nexport const StyledFakeInput = styled.span `\n  ${DisplayInputStyles};\n  border: 2px solid;\n  border-color: ${props => buildDisplayInputBorderColor(props)};\n  color: ${props => buildCheckIconColor(props)};\n  cursor: ${props => (props.disabled ? 'not-allowed' : 'pointer')};\n  margin: ${props => props.textPosition === 'left'\r\n    ? `${props.theme.spaceScale.spacing01} 0 0 ${props.theme.spaceScale.spacing03}`\r\n    : `0 ${props.theme.spaceScale.spacing03} 0 0`};\n\n  svg {\n    flex-shrink: 0;\n    pointer-events: none;\n    transition: all 0.2s ease-out;\n  }\n\n  ${HiddenInput}:focus + label & {\n    &:before {\n      ${props => !props.hideFocus && buildDisplayInputFocusStyles(props)};\n    }\n  }\n\n  &:after {\n    // active state\n    background: ${props => buildDisplayInputActiveBackground(props)};\n    top: -10px;\n    left: -10px;\n  }\n`;\r\nexport const Checkbox = React.memo(React.forwardRef((props, ref) => {\r\n    const { checked, id: defaultId, defaultChecked, onChange } = props;\r\n    const isControlled = typeof checked === 'boolean';\r\n    // Local state only for uncontrolled usage; controlled reads directly\r\n    // from the `checked` prop to avoid an extra render per change.\r\n    const [uncontrolledChecked, setUncontrolledChecked] = React.useState(Boolean(defaultChecked));\r\n    const isChecked = isControlled ? checked : uncontrolledChecked;\r\n    const id = useGenerateId(defaultId);\r\n    function handleChange(event) {\r\n        const { checked: targetChecked } = event.target;\r\n        if (typeof onChange === 'function') {\r\n            onChange(event);\r\n        }\r\n        if (!isControlled) {\r\n            setUncontrolledChecked(targetChecked);\r\n        }\r\n    }\r\n    const theme = React.useContext(ThemeContext);\r\n    const context = React.useContext(FormGroupContext);\r\n    const { color = theme.colors.primary, containerStyle, disabled, errorMessage, inputStyle, labelStyle, labelText, isTextVisuallyHidden, testId, textPosition, ariaLabel, ...rest } = props;\r\n    const other = omit(['defaultChecked'], rest);\r\n    const descriptionId = errorMessage && `${id}${descriptionSuffix}`;\r\n    const groupDescriptionId = context.descriptionId;\r\n    const describedBy = descriptionId && groupDescriptionId\r\n        ? `${groupDescriptionId} ${descriptionId}`\r\n        : descriptionId\r\n            ? descriptionId\r\n            : groupDescriptionId\r\n                ? groupDescriptionId\r\n                : null;\r\n    const hasError = context.hasError || !!errorMessage;\r\n    const isInverse = useIsInverse(props.isInverse);\r\n    return (React.createElement(React.Fragment, null,\r\n        React.createElement(StyledContainer, { style: containerStyle },\r\n            React.createElement(HiddenInput, Object.assign({}, other, { \"aria-label\": ariaLabel ?? reactNodeToString(labelText), \"aria-describedby\": describedBy, id: id, \"data-testid\": testId, checked: isChecked, disabled: disabled, ref: ref, type: \"checkbox\", onChange: handleChange })),\r\n            React.createElement(StyledLabel, { htmlFor: id, isInverse: isInverse, style: labelStyle },\r\n                !isTextVisuallyHidden &&\r\n                    textPosition === CheckboxTextPosition.left &&\r\n                    labelText,\r\n                React.createElement(StyledFakeInput, { isChecked: isChecked, color: color, disabled: disabled, hasError: hasError, hideFocus: props.hideFocus, isInverse: isInverse, style: inputStyle, textPosition: textPosition, theme: theme, \"aria-hidden\": \"true\" }, isChecked ? (React.createElement(CheckBoxIcon, { size: theme.iconSizes.medium })) : (React.createElement(CheckBoxOutlineBlankIcon, { size: theme.iconSizes.medium }))),\r\n                isTextVisuallyHidden ? (React.createElement(HiddenLabelText, null, labelText)) : (textPosition !== CheckboxTextPosition.left &&\r\n                    labelText &&\r\n                    labelText))),\r\n        !!errorMessage && (React.createElement(InputMessage, { id: descriptionId, hasError: true, isInverse: isInverse }, errorMessage))));\r\n}));\r\n//# sourceMappingURL=index.js.map"]} */"));
-var HiddenInput = /*#__PURE__*/_styled("input", {
-  target: "e1iwfc8c1",
-  label: "HiddenInput"
-})(HiddenStyles, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AAqBwC","file":"index.tsx","sourcesContent":["import * as React from 'react';\r\nimport styled from '@emotion/styled';\r\nimport { transparentize } from 'polished';\r\nimport { CheckBoxIcon, CheckBoxOutlineBlankIcon } from 'react-magma-icons';\r\nimport { useIsInverse } from '../../inverse';\r\nimport { ThemeContext } from '../../theme/ThemeContext';\r\nimport { descriptionSuffix, omit, reactNodeToString, useGenerateId, } from '../../utils';\r\nimport { HiddenStyles } from '../../utils/UtilityStyles';\r\nimport { FormGroupContext } from '../FormGroup';\r\nimport { InputMessage } from '../Input/InputMessage';\r\nimport { DisplayInputStyles, buildDisplayInputActiveBackground, buildDisplayInputBorderColor, buildDisplayInputFocusStyles, } from '../SelectionControls/InputStyles';\r\nimport { StyledContainer } from '../SelectionControls/StyledContainer';\r\nimport { StyledLabel } from '../SelectionControls/StyledLabel';\r\nexport var CheckboxTextPosition;\r\n(function (CheckboxTextPosition) {\r\n    CheckboxTextPosition[\"left\"] = \"left\";\r\n    CheckboxTextPosition[\"right\"] = \"right\";\r\n})(CheckboxTextPosition || (CheckboxTextPosition = {}));\r\nexport const HiddenLabelText = styled.span `\n  ${HiddenStyles};\n`;\r\nexport const HiddenInput = styled.input `\n  ${HiddenStyles};\n`;\r\nfunction buildCheckIconColor(props) {\r\n    if (props.disabled) {\r\n        if (props.isInverse) {\r\n            return transparentize(0.6, props.theme.colors.neutral100);\r\n        }\r\n        return props.theme.colors.neutral300;\r\n    }\r\n    if (props.isInverse) {\r\n        return props.theme.colors.neutral100;\r\n    }\r\n    if (props.isChecked || props.isIndeterminate) {\r\n        return props.color;\r\n    }\r\n    return props.theme.colors.neutral700;\r\n}\r\nexport const StyledFakeInput = styled.span `\n  ${DisplayInputStyles};\n  border: 2px solid;\n  border-color: ${props => buildDisplayInputBorderColor(props)};\n  color: ${props => buildCheckIconColor(props)};\n  cursor: ${props => (props.disabled ? 'not-allowed' : 'pointer')};\n  margin: ${props => props.textPosition === 'left'\r\n    ? `${props.theme.spaceScale.spacing01} 0 0 ${props.theme.spaceScale.spacing03}`\r\n    : `0 ${props.theme.spaceScale.spacing03} 0 0`};\n\n  svg {\n    flex-shrink: 0;\n    pointer-events: none;\n    transition: all 0.2s ease-out;\n  }\n\n  ${HiddenInput}:focus + label & {\n    &:before {\n      ${props => !props.hideFocus && buildDisplayInputFocusStyles(props)};\n    }\n  }\n\n  &:after {\n    // active state\n    background: ${props => buildDisplayInputActiveBackground(props)};\n    top: -10px;\n    left: -10px;\n  }\n`;\r\nexport const Checkbox = React.memo(React.forwardRef((props, ref) => {\r\n    const { checked, id: defaultId, defaultChecked, onChange } = props;\r\n    const isControlled = typeof checked === 'boolean';\r\n    // Local state only for uncontrolled usage; controlled reads directly\r\n    // from the `checked` prop to avoid an extra render per change.\r\n    const [uncontrolledChecked, setUncontrolledChecked] = React.useState(Boolean(defaultChecked));\r\n    const isChecked = isControlled ? checked : uncontrolledChecked;\r\n    const id = useGenerateId(defaultId);\r\n    function handleChange(event) {\r\n        const { checked: targetChecked } = event.target;\r\n        if (typeof onChange === 'function') {\r\n            onChange(event);\r\n        }\r\n        if (!isControlled) {\r\n            setUncontrolledChecked(targetChecked);\r\n        }\r\n    }\r\n    const theme = React.useContext(ThemeContext);\r\n    const context = React.useContext(FormGroupContext);\r\n    const { color = theme.colors.primary, containerStyle, disabled, errorMessage, inputStyle, labelStyle, labelText, isTextVisuallyHidden, testId, textPosition, ariaLabel, ...rest } = props;\r\n    const other = omit(['defaultChecked'], rest);\r\n    const descriptionId = errorMessage && `${id}${descriptionSuffix}`;\r\n    const groupDescriptionId = context.descriptionId;\r\n    const describedBy = descriptionId && groupDescriptionId\r\n        ? `${groupDescriptionId} ${descriptionId}`\r\n        : descriptionId\r\n            ? descriptionId\r\n            : groupDescriptionId\r\n                ? groupDescriptionId\r\n                : null;\r\n    const hasError = context.hasError || !!errorMessage;\r\n    const isInverse = useIsInverse(props.isInverse);\r\n    return (React.createElement(React.Fragment, null,\r\n        React.createElement(StyledContainer, { style: containerStyle },\r\n            React.createElement(HiddenInput, Object.assign({}, other, { \"aria-label\": ariaLabel ?? reactNodeToString(labelText), \"aria-describedby\": describedBy, id: id, \"data-testid\": testId, checked: isChecked, disabled: disabled, ref: ref, type: \"checkbox\", onChange: handleChange })),\r\n            React.createElement(StyledLabel, { htmlFor: id, isInverse: isInverse, style: labelStyle },\r\n                !isTextVisuallyHidden &&\r\n                    textPosition === CheckboxTextPosition.left &&\r\n                    labelText,\r\n                React.createElement(StyledFakeInput, { isChecked: isChecked, color: color, disabled: disabled, hasError: hasError, hideFocus: props.hideFocus, isInverse: isInverse, style: inputStyle, textPosition: textPosition, theme: theme, \"aria-hidden\": \"true\" }, isChecked ? (React.createElement(CheckBoxIcon, { size: theme.iconSizes.medium })) : (React.createElement(CheckBoxOutlineBlankIcon, { size: theme.iconSizes.medium }))),\r\n                isTextVisuallyHidden ? (React.createElement(HiddenLabelText, null, labelText)) : (textPosition !== CheckboxTextPosition.left &&\r\n                    labelText &&\r\n                    labelText))),\r\n        !!errorMessage && (React.createElement(InputMessage, { id: descriptionId, hasError: true, isInverse: isInverse }, errorMessage))));\r\n}));\r\n//# sourceMappingURL=index.js.map"]} */"));
+})(HiddenStyles, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AAkE2C","file":"index.tsx","sourcesContent":["import * as React from 'react';\r\nimport isPropValid from '@emotion/is-prop-valid';\r\nimport { css, withEmotionCache, } from '@emotion/react';\r\nimport styled from '@emotion/styled';\r\nimport { insertStyles } from '@emotion/utils';\r\nimport { transparentize } from 'polished';\r\nimport { CheckBoxIcon, CheckBoxOutlineBlankIcon } from 'react-magma-icons';\r\nimport { useIsInverse } from '../../inverse';\r\nimport { ThemeContext } from '../../theme/ThemeContext';\r\nimport { descriptionSuffix, omit, reactNodeToString, useGenerateId, } from '../../utils';\r\nimport { HiddenStyles } from '../../utils/UtilityStyles';\r\nimport { FormGroupContext } from '../FormGroup';\r\nimport { InputMessage } from '../Input/InputMessage';\r\nimport { DisplayInputStyles, buildDisplayInputActiveBackground, buildDisplayInputBorderColor, buildDisplayInputFocusStyles, } from '../SelectionControls/InputStyles';\r\nimport { StyledContainer } from '../SelectionControls/StyledContainer';\r\nimport { StyledLabel } from '../SelectionControls/StyledLabel';\r\nexport var CheckboxTextPosition;\r\n(function (CheckboxTextPosition) {\r\n    CheckboxTextPosition[\"left\"] = \"left\";\r\n    CheckboxTextPosition[\"right\"] = \"right\";\r\n})(CheckboxTextPosition || (CheckboxTextPosition = {}));\r\n// Style-caching helpers for rendering checkboxes cheaply in large lists.\r\nconst isBrowser = typeof document !== 'undefined';\r\n// Inserts cached styles into the active Emotion cache; returns the class name\r\n// (and, during SSR, the inline <style> to render).\r\nfunction insertCachedStyles(cache, serialized) {\r\n    const rules = insertStyles(cache, serialized, true);\r\n    const className = `${cache.key}-${serialized.name}`;\r\n    let styles = null;\r\n    if (!isBrowser && rules !== undefined) {\r\n        let serializedNames = serialized.name;\r\n        let next = serialized.next;\r\n        while (next !== undefined) {\r\n            serializedNames += ` ${next.name}`;\r\n            next = next.next;\r\n        }\r\n        styles = React.createElement('style', {\r\n            'data-emotion': `${cache.key} ${serializedNames}`,\r\n            dangerouslySetInnerHTML: { __html: rules },\r\n            nonce: cache.sheet.nonce,\r\n        });\r\n    }\r\n    return { className, styles };\r\n}\r\n// Serializes styles once per unique (theme, variant) pair and caches the result.\r\nfunction createVariantStyles(build, getVariantKey, getTheme) {\r\n    const cacheByTheme = new WeakMap();\r\n    return function resolveStyles(props) {\r\n        const theme = getTheme(props);\r\n        let variants = cacheByTheme.get(theme);\r\n        if (!variants) {\r\n            variants = new Map();\r\n            cacheByTheme.set(theme, variants);\r\n        }\r\n        const key = getVariantKey(props);\r\n        let serialized = variants.get(key);\r\n        if (!serialized) {\r\n            serialized = build(props);\r\n            variants.set(key, serialized);\r\n        }\r\n        return serialized;\r\n    };\r\n}\r\nfunction cx(...classNames) {\r\n    return classNames.filter(Boolean).join(' ');\r\n}\r\nexport const HiddenLabelText = styled.span `\n  ${HiddenStyles};\n`;\r\n// Stable class on the hidden input, used by the fake input's sibling focus selector.\r\nexport const checkboxInputClassName = 'magma-checkbox-input';\r\nexport const HiddenInput = withEmotionCache((props, cache, ref) => {\r\n    const { className, ...rest } = props;\r\n    const { className: hiddenClassName, styles } = insertCachedStyles(cache, HiddenStyles);\r\n    // Forward only valid DOM attributes (as styled does for string tags).\r\n    const domProps = {};\r\n    Object.keys(rest).forEach(key => {\r\n        if (isPropValid(key)) {\r\n            domProps[key] = rest[key];\r\n        }\r\n    });\r\n    const input = (React.createElement(\"input\", Object.assign({}, domProps, { ref: ref, className: cx(hiddenClassName, checkboxInputClassName, className) })));\r\n    return styles ? (React.createElement(React.Fragment, null,\r\n        styles,\r\n        input)) : (input);\r\n});\r\nfunction buildCheckIconColor(props) {\r\n    if (props.disabled) {\r\n        if (props.isInverse) {\r\n            return transparentize(0.6, props.theme.colors.neutral100);\r\n        }\r\n        return props.theme.colors.neutral300;\r\n    }\r\n    if (props.isInverse) {\r\n        return props.theme.colors.neutral100;\r\n    }\r\n    if (props.isChecked || props.isIndeterminate) {\r\n        return props.color;\r\n    }\r\n    return props.theme.colors.neutral700;\r\n}\r\n// Fake input (the checkbox box) styles, cached per (theme, variant).\r\nconst resolveFakeInputStyles = createVariantStyles(props => css `\n    ${DisplayInputStyles(props)};\n    border: 2px solid;\n    border-color: ${buildDisplayInputBorderColor(props)};\n    color: ${buildCheckIconColor(props)};\n    cursor: ${props.disabled ? 'not-allowed' : 'pointer'};\n    margin: ${props.textPosition === 'left'\r\n    ? `${props.theme.spaceScale.spacing01} 0 0 ${props.theme.spaceScale.spacing03}`\r\n    : `0 ${props.theme.spaceScale.spacing03} 0 0`};\n\n    svg {\n      flex-shrink: 0;\n      pointer-events: none;\n      transition: all 0.2s ease-out;\n    }\n\n    .${checkboxInputClassName}:focus + label & {\n      &:before {\n        ${!props.hideFocus && buildDisplayInputFocusStyles(props)};\n      }\n    }\n\n    &:after {\n      // active state\n      background: ${buildDisplayInputActiveBackground(props)};\n      top: -10px;\n      left: -10px;\n    }\n  `, props => [\r\n    props.isChecked,\r\n    props.isIndeterminate,\r\n    props.disabled,\r\n    props.isInverse,\r\n    props.hasError,\r\n    props.hideFocus,\r\n    props.textPosition,\r\n    props.color,\r\n].join('|'), props => props.theme);\r\nexport const StyledFakeInput = withEmotionCache(({ children, style, 'aria-hidden': ariaHidden = true, ...styleProps }, cache) => {\r\n    const { className, styles } = insertCachedStyles(cache, resolveFakeInputStyles(styleProps));\r\n    const fakeInput = (React.createElement(\"span\", { className: className, style: style, \"aria-hidden\": ariaHidden }, children));\r\n    return styles ? (React.createElement(React.Fragment, null,\r\n        styles,\r\n        fakeInput)) : (fakeInput);\r\n});\r\nexport const Checkbox = React.memo(React.forwardRef((props, ref) => {\r\n    const { checked, id: defaultId, defaultChecked, onChange } = props;\r\n    const isControlled = typeof checked === 'boolean';\r\n    // Local state only for uncontrolled usage; controlled reads directly\r\n    // from the `checked` prop to avoid an extra render per change.\r\n    const [uncontrolledChecked, setUncontrolledChecked] = React.useState(Boolean(defaultChecked));\r\n    const isChecked = isControlled ? checked : uncontrolledChecked;\r\n    const id = useGenerateId(defaultId);\r\n    function handleChange(event) {\r\n        const { checked: targetChecked } = event.target;\r\n        if (typeof onChange === 'function') {\r\n            onChange(event);\r\n        }\r\n        if (!isControlled) {\r\n            setUncontrolledChecked(targetChecked);\r\n        }\r\n    }\r\n    const theme = React.useContext(ThemeContext);\r\n    const context = React.useContext(FormGroupContext);\r\n    const { color = theme.colors.primary, containerStyle, disabled, errorMessage, inputStyle, labelStyle, labelText, isTextVisuallyHidden, testId, textPosition, ariaLabel, ...rest } = props;\r\n    const other = omit(['defaultChecked'], rest);\r\n    const descriptionId = errorMessage && `${id}${descriptionSuffix}`;\r\n    const groupDescriptionId = context.descriptionId;\r\n    const describedBy = descriptionId && groupDescriptionId\r\n        ? `${groupDescriptionId} ${descriptionId}`\r\n        : descriptionId\r\n            ? descriptionId\r\n            : groupDescriptionId\r\n                ? groupDescriptionId\r\n                : null;\r\n    const hasError = context.hasError || !!errorMessage;\r\n    const isInverse = useIsInverse(props.isInverse);\r\n    const iconSize = theme.iconSizes.medium;\r\n    // Memoized so re-renders reuse the same icon element.\r\n    const checkboxIcon = React.useMemo(() => isChecked ? (React.createElement(CheckBoxIcon, { size: iconSize })) : (React.createElement(CheckBoxOutlineBlankIcon, { size: iconSize })), [isChecked, iconSize]);\r\n    return (React.createElement(React.Fragment, null,\r\n        React.createElement(StyledContainer, { style: containerStyle },\r\n            React.createElement(HiddenInput, Object.assign({}, other, { \"aria-label\": ariaLabel ?? reactNodeToString(labelText), \"aria-describedby\": describedBy, id: id, \"data-testid\": testId, checked: isChecked, disabled: disabled, ref: ref, type: \"checkbox\", onChange: handleChange })),\r\n            React.createElement(StyledLabel, { htmlFor: id, isInverse: isInverse, style: labelStyle },\r\n                !isTextVisuallyHidden &&\r\n                    textPosition === CheckboxTextPosition.left &&\r\n                    labelText,\r\n                React.createElement(StyledFakeInput, { isChecked: isChecked, color: color, disabled: disabled, hasError: hasError, hideFocus: props.hideFocus, isInverse: isInverse, style: inputStyle, textPosition: textPosition, theme: theme, \"aria-hidden\": \"true\" }, checkboxIcon),\r\n                isTextVisuallyHidden ? (React.createElement(HiddenLabelText, null, labelText)) : (textPosition !== CheckboxTextPosition.left &&\r\n                    labelText &&\r\n                    labelText))),\r\n        !!errorMessage && (React.createElement(InputMessage, { id: descriptionId, hasError: true, isInverse: isInverse }, errorMessage))));\r\n}));\r\n//# sourceMappingURL=index.js.map"]} */"));
+// Stable class on the hidden input, used by the fake input's sibling focus selector.
+var checkboxInputClassName = 'magma-checkbox-input';
+var HiddenInput = /*#__PURE__*/withEmotionCache(function (props, cache, ref) {
+  var className = props.className,
+    rest = _objectWithoutPropertiesLoose(props, _excluded$q);
+  var _insertCachedStyles = insertCachedStyles(cache, HiddenStyles),
+    hiddenClassName = _insertCachedStyles.className,
+    styles = _insertCachedStyles.styles;
+  // Forward only valid DOM attributes (as styled does for string tags).
+  var domProps = {};
+  Object.keys(rest).forEach(function (key) {
+    if (isPropValid(key)) {
+      domProps[key] = rest[key];
+    }
+  });
+  var input = createElement("input", Object.assign({}, domProps, {
+    ref: ref,
+    className: cx(hiddenClassName, checkboxInputClassName, className)
+  }));
+  return styles ? createElement(Fragment, null, styles, input) : input;
+});
 function buildCheckIconColor(props) {
   if (props.disabled) {
     if (props.isInverse) {
@@ -6260,22 +6369,30 @@ function buildCheckIconColor(props) {
   }
   return props.theme.colors.neutral700;
 }
-var StyledFakeInput = /*#__PURE__*/_styled("span", {
-  target: "e1iwfc8c0",
-  label: "StyledFakeInput"
-})(DisplayInputStyles, ";border:2px solid;border-color:", function (props) {
-  return buildDisplayInputBorderColor(props);
-}, ";color:", function (props) {
-  return buildCheckIconColor(props);
-}, ";cursor:", function (props) {
-  return props.disabled ? 'not-allowed' : 'pointer';
-}, ";margin:", function (props) {
-  return props.textPosition === 'left' ? props.theme.spaceScale.spacing01 + " 0 0 " + props.theme.spaceScale.spacing03 : "0 " + props.theme.spaceScale.spacing03 + " 0 0";
-}, ";svg{flex-shrink:0;pointer-events:none;transition:all 0.2s ease-out;}", HiddenInput, ":focus+label &{&:before{", function (props) {
-  return !props.hideFocus && buildDisplayInputFocusStyles(props);
-}, ";}}&:after{background:", function (props) {
-  return buildDisplayInputActiveBackground(props);
-}, ";top:-10px;left:-10px;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AAuC2C","file":"index.tsx","sourcesContent":["import * as React from 'react';\r\nimport styled from '@emotion/styled';\r\nimport { transparentize } from 'polished';\r\nimport { CheckBoxIcon, CheckBoxOutlineBlankIcon } from 'react-magma-icons';\r\nimport { useIsInverse } from '../../inverse';\r\nimport { ThemeContext } from '../../theme/ThemeContext';\r\nimport { descriptionSuffix, omit, reactNodeToString, useGenerateId, } from '../../utils';\r\nimport { HiddenStyles } from '../../utils/UtilityStyles';\r\nimport { FormGroupContext } from '../FormGroup';\r\nimport { InputMessage } from '../Input/InputMessage';\r\nimport { DisplayInputStyles, buildDisplayInputActiveBackground, buildDisplayInputBorderColor, buildDisplayInputFocusStyles, } from '../SelectionControls/InputStyles';\r\nimport { StyledContainer } from '../SelectionControls/StyledContainer';\r\nimport { StyledLabel } from '../SelectionControls/StyledLabel';\r\nexport var CheckboxTextPosition;\r\n(function (CheckboxTextPosition) {\r\n    CheckboxTextPosition[\"left\"] = \"left\";\r\n    CheckboxTextPosition[\"right\"] = \"right\";\r\n})(CheckboxTextPosition || (CheckboxTextPosition = {}));\r\nexport const HiddenLabelText = styled.span `\n  ${HiddenStyles};\n`;\r\nexport const HiddenInput = styled.input `\n  ${HiddenStyles};\n`;\r\nfunction buildCheckIconColor(props) {\r\n    if (props.disabled) {\r\n        if (props.isInverse) {\r\n            return transparentize(0.6, props.theme.colors.neutral100);\r\n        }\r\n        return props.theme.colors.neutral300;\r\n    }\r\n    if (props.isInverse) {\r\n        return props.theme.colors.neutral100;\r\n    }\r\n    if (props.isChecked || props.isIndeterminate) {\r\n        return props.color;\r\n    }\r\n    return props.theme.colors.neutral700;\r\n}\r\nexport const StyledFakeInput = styled.span `\n  ${DisplayInputStyles};\n  border: 2px solid;\n  border-color: ${props => buildDisplayInputBorderColor(props)};\n  color: ${props => buildCheckIconColor(props)};\n  cursor: ${props => (props.disabled ? 'not-allowed' : 'pointer')};\n  margin: ${props => props.textPosition === 'left'\r\n    ? `${props.theme.spaceScale.spacing01} 0 0 ${props.theme.spaceScale.spacing03}`\r\n    : `0 ${props.theme.spaceScale.spacing03} 0 0`};\n\n  svg {\n    flex-shrink: 0;\n    pointer-events: none;\n    transition: all 0.2s ease-out;\n  }\n\n  ${HiddenInput}:focus + label & {\n    &:before {\n      ${props => !props.hideFocus && buildDisplayInputFocusStyles(props)};\n    }\n  }\n\n  &:after {\n    // active state\n    background: ${props => buildDisplayInputActiveBackground(props)};\n    top: -10px;\n    left: -10px;\n  }\n`;\r\nexport const Checkbox = React.memo(React.forwardRef((props, ref) => {\r\n    const { checked, id: defaultId, defaultChecked, onChange } = props;\r\n    const isControlled = typeof checked === 'boolean';\r\n    // Local state only for uncontrolled usage; controlled reads directly\r\n    // from the `checked` prop to avoid an extra render per change.\r\n    const [uncontrolledChecked, setUncontrolledChecked] = React.useState(Boolean(defaultChecked));\r\n    const isChecked = isControlled ? checked : uncontrolledChecked;\r\n    const id = useGenerateId(defaultId);\r\n    function handleChange(event) {\r\n        const { checked: targetChecked } = event.target;\r\n        if (typeof onChange === 'function') {\r\n            onChange(event);\r\n        }\r\n        if (!isControlled) {\r\n            setUncontrolledChecked(targetChecked);\r\n        }\r\n    }\r\n    const theme = React.useContext(ThemeContext);\r\n    const context = React.useContext(FormGroupContext);\r\n    const { color = theme.colors.primary, containerStyle, disabled, errorMessage, inputStyle, labelStyle, labelText, isTextVisuallyHidden, testId, textPosition, ariaLabel, ...rest } = props;\r\n    const other = omit(['defaultChecked'], rest);\r\n    const descriptionId = errorMessage && `${id}${descriptionSuffix}`;\r\n    const groupDescriptionId = context.descriptionId;\r\n    const describedBy = descriptionId && groupDescriptionId\r\n        ? `${groupDescriptionId} ${descriptionId}`\r\n        : descriptionId\r\n            ? descriptionId\r\n            : groupDescriptionId\r\n                ? groupDescriptionId\r\n                : null;\r\n    const hasError = context.hasError || !!errorMessage;\r\n    const isInverse = useIsInverse(props.isInverse);\r\n    return (React.createElement(React.Fragment, null,\r\n        React.createElement(StyledContainer, { style: containerStyle },\r\n            React.createElement(HiddenInput, Object.assign({}, other, { \"aria-label\": ariaLabel ?? reactNodeToString(labelText), \"aria-describedby\": describedBy, id: id, \"data-testid\": testId, checked: isChecked, disabled: disabled, ref: ref, type: \"checkbox\", onChange: handleChange })),\r\n            React.createElement(StyledLabel, { htmlFor: id, isInverse: isInverse, style: labelStyle },\r\n                !isTextVisuallyHidden &&\r\n                    textPosition === CheckboxTextPosition.left &&\r\n                    labelText,\r\n                React.createElement(StyledFakeInput, { isChecked: isChecked, color: color, disabled: disabled, hasError: hasError, hideFocus: props.hideFocus, isInverse: isInverse, style: inputStyle, textPosition: textPosition, theme: theme, \"aria-hidden\": \"true\" }, isChecked ? (React.createElement(CheckBoxIcon, { size: theme.iconSizes.medium })) : (React.createElement(CheckBoxOutlineBlankIcon, { size: theme.iconSizes.medium }))),\r\n                isTextVisuallyHidden ? (React.createElement(HiddenLabelText, null, labelText)) : (textPosition !== CheckboxTextPosition.left &&\r\n                    labelText &&\r\n                    labelText))),\r\n        !!errorMessage && (React.createElement(InputMessage, { id: descriptionId, hasError: true, isInverse: isInverse }, errorMessage))));\r\n}));\r\n//# sourceMappingURL=index.js.map"]} */"));
+// Fake input (the checkbox box) styles, cached per (theme, variant).
+var resolveFakeInputStyles = /*#__PURE__*/createVariantStyles(function (props) {
+  return /*#__PURE__*/css(DisplayInputStyles(props), ";border:2px solid;border-color:", buildDisplayInputBorderColor(props), ";color:", buildCheckIconColor(props), ";cursor:", props.disabled ? 'not-allowed' : 'pointer', ";margin:", props.textPosition === 'left' ? props.theme.spaceScale.spacing01 + " 0 0 " + props.theme.spaceScale.spacing03 : "0 " + props.theme.spaceScale.spacing03 + " 0 0", ";svg{flex-shrink:0;pointer-events:none;transition:all 0.2s ease-out;}.", checkboxInputClassName, ":focus+label &{&:before{", !props.hideFocus && buildDisplayInputFocusStyles(props), ";}}&:after{background:", buildDisplayInputActiveBackground(props), ";top:-10px;left:-10px;};label:resolveFakeInputStyles;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AAsGgE","file":"index.tsx","sourcesContent":["import * as React from 'react';\r\nimport isPropValid from '@emotion/is-prop-valid';\r\nimport { css, withEmotionCache, } from '@emotion/react';\r\nimport styled from '@emotion/styled';\r\nimport { insertStyles } from '@emotion/utils';\r\nimport { transparentize } from 'polished';\r\nimport { CheckBoxIcon, CheckBoxOutlineBlankIcon } from 'react-magma-icons';\r\nimport { useIsInverse } from '../../inverse';\r\nimport { ThemeContext } from '../../theme/ThemeContext';\r\nimport { descriptionSuffix, omit, reactNodeToString, useGenerateId, } from '../../utils';\r\nimport { HiddenStyles } from '../../utils/UtilityStyles';\r\nimport { FormGroupContext } from '../FormGroup';\r\nimport { InputMessage } from '../Input/InputMessage';\r\nimport { DisplayInputStyles, buildDisplayInputActiveBackground, buildDisplayInputBorderColor, buildDisplayInputFocusStyles, } from '../SelectionControls/InputStyles';\r\nimport { StyledContainer } from '../SelectionControls/StyledContainer';\r\nimport { StyledLabel } from '../SelectionControls/StyledLabel';\r\nexport var CheckboxTextPosition;\r\n(function (CheckboxTextPosition) {\r\n    CheckboxTextPosition[\"left\"] = \"left\";\r\n    CheckboxTextPosition[\"right\"] = \"right\";\r\n})(CheckboxTextPosition || (CheckboxTextPosition = {}));\r\n// Style-caching helpers for rendering checkboxes cheaply in large lists.\r\nconst isBrowser = typeof document !== 'undefined';\r\n// Inserts cached styles into the active Emotion cache; returns the class name\r\n// (and, during SSR, the inline <style> to render).\r\nfunction insertCachedStyles(cache, serialized) {\r\n    const rules = insertStyles(cache, serialized, true);\r\n    const className = `${cache.key}-${serialized.name}`;\r\n    let styles = null;\r\n    if (!isBrowser && rules !== undefined) {\r\n        let serializedNames = serialized.name;\r\n        let next = serialized.next;\r\n        while (next !== undefined) {\r\n            serializedNames += ` ${next.name}`;\r\n            next = next.next;\r\n        }\r\n        styles = React.createElement('style', {\r\n            'data-emotion': `${cache.key} ${serializedNames}`,\r\n            dangerouslySetInnerHTML: { __html: rules },\r\n            nonce: cache.sheet.nonce,\r\n        });\r\n    }\r\n    return { className, styles };\r\n}\r\n// Serializes styles once per unique (theme, variant) pair and caches the result.\r\nfunction createVariantStyles(build, getVariantKey, getTheme) {\r\n    const cacheByTheme = new WeakMap();\r\n    return function resolveStyles(props) {\r\n        const theme = getTheme(props);\r\n        let variants = cacheByTheme.get(theme);\r\n        if (!variants) {\r\n            variants = new Map();\r\n            cacheByTheme.set(theme, variants);\r\n        }\r\n        const key = getVariantKey(props);\r\n        let serialized = variants.get(key);\r\n        if (!serialized) {\r\n            serialized = build(props);\r\n            variants.set(key, serialized);\r\n        }\r\n        return serialized;\r\n    };\r\n}\r\nfunction cx(...classNames) {\r\n    return classNames.filter(Boolean).join(' ');\r\n}\r\nexport const HiddenLabelText = styled.span `\n  ${HiddenStyles};\n`;\r\n// Stable class on the hidden input, used by the fake input's sibling focus selector.\r\nexport const checkboxInputClassName = 'magma-checkbox-input';\r\nexport const HiddenInput = withEmotionCache((props, cache, ref) => {\r\n    const { className, ...rest } = props;\r\n    const { className: hiddenClassName, styles } = insertCachedStyles(cache, HiddenStyles);\r\n    // Forward only valid DOM attributes (as styled does for string tags).\r\n    const domProps = {};\r\n    Object.keys(rest).forEach(key => {\r\n        if (isPropValid(key)) {\r\n            domProps[key] = rest[key];\r\n        }\r\n    });\r\n    const input = (React.createElement(\"input\", Object.assign({}, domProps, { ref: ref, className: cx(hiddenClassName, checkboxInputClassName, className) })));\r\n    return styles ? (React.createElement(React.Fragment, null,\r\n        styles,\r\n        input)) : (input);\r\n});\r\nfunction buildCheckIconColor(props) {\r\n    if (props.disabled) {\r\n        if (props.isInverse) {\r\n            return transparentize(0.6, props.theme.colors.neutral100);\r\n        }\r\n        return props.theme.colors.neutral300;\r\n    }\r\n    if (props.isInverse) {\r\n        return props.theme.colors.neutral100;\r\n    }\r\n    if (props.isChecked || props.isIndeterminate) {\r\n        return props.color;\r\n    }\r\n    return props.theme.colors.neutral700;\r\n}\r\n// Fake input (the checkbox box) styles, cached per (theme, variant).\r\nconst resolveFakeInputStyles = createVariantStyles(props => css `\n    ${DisplayInputStyles(props)};\n    border: 2px solid;\n    border-color: ${buildDisplayInputBorderColor(props)};\n    color: ${buildCheckIconColor(props)};\n    cursor: ${props.disabled ? 'not-allowed' : 'pointer'};\n    margin: ${props.textPosition === 'left'\r\n    ? `${props.theme.spaceScale.spacing01} 0 0 ${props.theme.spaceScale.spacing03}`\r\n    : `0 ${props.theme.spaceScale.spacing03} 0 0`};\n\n    svg {\n      flex-shrink: 0;\n      pointer-events: none;\n      transition: all 0.2s ease-out;\n    }\n\n    .${checkboxInputClassName}:focus + label & {\n      &:before {\n        ${!props.hideFocus && buildDisplayInputFocusStyles(props)};\n      }\n    }\n\n    &:after {\n      // active state\n      background: ${buildDisplayInputActiveBackground(props)};\n      top: -10px;\n      left: -10px;\n    }\n  `, props => [\r\n    props.isChecked,\r\n    props.isIndeterminate,\r\n    props.disabled,\r\n    props.isInverse,\r\n    props.hasError,\r\n    props.hideFocus,\r\n    props.textPosition,\r\n    props.color,\r\n].join('|'), props => props.theme);\r\nexport const StyledFakeInput = withEmotionCache(({ children, style, 'aria-hidden': ariaHidden = true, ...styleProps }, cache) => {\r\n    const { className, styles } = insertCachedStyles(cache, resolveFakeInputStyles(styleProps));\r\n    const fakeInput = (React.createElement(\"span\", { className: className, style: style, \"aria-hidden\": ariaHidden }, children));\r\n    return styles ? (React.createElement(React.Fragment, null,\r\n        styles,\r\n        fakeInput)) : (fakeInput);\r\n});\r\nexport const Checkbox = React.memo(React.forwardRef((props, ref) => {\r\n    const { checked, id: defaultId, defaultChecked, onChange } = props;\r\n    const isControlled = typeof checked === 'boolean';\r\n    // Local state only for uncontrolled usage; controlled reads directly\r\n    // from the `checked` prop to avoid an extra render per change.\r\n    const [uncontrolledChecked, setUncontrolledChecked] = React.useState(Boolean(defaultChecked));\r\n    const isChecked = isControlled ? checked : uncontrolledChecked;\r\n    const id = useGenerateId(defaultId);\r\n    function handleChange(event) {\r\n        const { checked: targetChecked } = event.target;\r\n        if (typeof onChange === 'function') {\r\n            onChange(event);\r\n        }\r\n        if (!isControlled) {\r\n            setUncontrolledChecked(targetChecked);\r\n        }\r\n    }\r\n    const theme = React.useContext(ThemeContext);\r\n    const context = React.useContext(FormGroupContext);\r\n    const { color = theme.colors.primary, containerStyle, disabled, errorMessage, inputStyle, labelStyle, labelText, isTextVisuallyHidden, testId, textPosition, ariaLabel, ...rest } = props;\r\n    const other = omit(['defaultChecked'], rest);\r\n    const descriptionId = errorMessage && `${id}${descriptionSuffix}`;\r\n    const groupDescriptionId = context.descriptionId;\r\n    const describedBy = descriptionId && groupDescriptionId\r\n        ? `${groupDescriptionId} ${descriptionId}`\r\n        : descriptionId\r\n            ? descriptionId\r\n            : groupDescriptionId\r\n                ? groupDescriptionId\r\n                : null;\r\n    const hasError = context.hasError || !!errorMessage;\r\n    const isInverse = useIsInverse(props.isInverse);\r\n    const iconSize = theme.iconSizes.medium;\r\n    // Memoized so re-renders reuse the same icon element.\r\n    const checkboxIcon = React.useMemo(() => isChecked ? (React.createElement(CheckBoxIcon, { size: iconSize })) : (React.createElement(CheckBoxOutlineBlankIcon, { size: iconSize })), [isChecked, iconSize]);\r\n    return (React.createElement(React.Fragment, null,\r\n        React.createElement(StyledContainer, { style: containerStyle },\r\n            React.createElement(HiddenInput, Object.assign({}, other, { \"aria-label\": ariaLabel ?? reactNodeToString(labelText), \"aria-describedby\": describedBy, id: id, \"data-testid\": testId, checked: isChecked, disabled: disabled, ref: ref, type: \"checkbox\", onChange: handleChange })),\r\n            React.createElement(StyledLabel, { htmlFor: id, isInverse: isInverse, style: labelStyle },\r\n                !isTextVisuallyHidden &&\r\n                    textPosition === CheckboxTextPosition.left &&\r\n                    labelText,\r\n                React.createElement(StyledFakeInput, { isChecked: isChecked, color: color, disabled: disabled, hasError: hasError, hideFocus: props.hideFocus, isInverse: isInverse, style: inputStyle, textPosition: textPosition, theme: theme, \"aria-hidden\": \"true\" }, checkboxIcon),\r\n                isTextVisuallyHidden ? (React.createElement(HiddenLabelText, null, labelText)) : (textPosition !== CheckboxTextPosition.left &&\r\n                    labelText &&\r\n                    labelText))),\r\n        !!errorMessage && (React.createElement(InputMessage, { id: descriptionId, hasError: true, isInverse: isInverse }, errorMessage))));\r\n}));\r\n//# sourceMappingURL=index.js.map"]} */"));
+}, function (props) {
+  return [props.isChecked, props.isIndeterminate, props.disabled, props.isInverse, props.hasError, props.hideFocus, props.textPosition, props.color].join('|');
+}, function (props) {
+  return props.theme;
+});
+var StyledFakeInput = /*#__PURE__*/withEmotionCache(function (_ref, cache) {
+  var children = _ref.children,
+    style = _ref.style,
+    _ref$ariaHidden = _ref['aria-hidden'],
+    ariaHidden = _ref$ariaHidden === void 0 ? true : _ref$ariaHidden,
+    styleProps = _objectWithoutPropertiesLoose(_ref, _excluded2$1);
+  var _insertCachedStyles2 = insertCachedStyles(cache, resolveFakeInputStyles(styleProps)),
+    className = _insertCachedStyles2.className,
+    styles = _insertCachedStyles2.styles;
+  var fakeInput = createElement("span", {
+    className: className,
+    style: style,
+    "aria-hidden": ariaHidden
+  }, children);
+  return styles ? createElement(Fragment, null, styles, fakeInput) : fakeInput;
+});
 var Checkbox = /*#__PURE__*/memo(/*#__PURE__*/forwardRef(function (props, ref) {
   var checked = props.checked,
     defaultId = props.id,
@@ -6312,13 +6429,22 @@ var Checkbox = /*#__PURE__*/memo(/*#__PURE__*/forwardRef(function (props, ref) {
     testId = props.testId,
     textPosition = props.textPosition,
     ariaLabel = props.ariaLabel,
-    rest = _objectWithoutPropertiesLoose(props, _excluded$q);
+    rest = _objectWithoutPropertiesLoose(props, _excluded3);
   var other = omit(['defaultChecked'], rest);
   var descriptionId = errorMessage && "" + id + descriptionSuffix;
   var groupDescriptionId = context.descriptionId;
   var describedBy = descriptionId && groupDescriptionId ? groupDescriptionId + " " + descriptionId : descriptionId ? descriptionId : groupDescriptionId ? groupDescriptionId : null;
   var hasError = context.hasError || !!errorMessage;
   var isInverse = useIsInverse(props.isInverse);
+  var iconSize = theme.iconSizes.medium;
+  // Memoized so re-renders reuse the same icon element.
+  var checkboxIcon = useMemo(function () {
+    return isChecked ? createElement(CheckBoxIcon, {
+      size: iconSize
+    }) : createElement(CheckBoxOutlineBlankIcon, {
+      size: iconSize
+    });
+  }, [isChecked, iconSize]);
   return createElement(Fragment, null, createElement(StyledContainer, {
     style: containerStyle
   }, createElement(HiddenInput, Object.assign({}, other, {
@@ -6346,11 +6472,7 @@ var Checkbox = /*#__PURE__*/memo(/*#__PURE__*/forwardRef(function (props, ref) {
     textPosition: textPosition,
     theme: theme,
     "aria-hidden": "true"
-  }, isChecked ? createElement(CheckBoxIcon, {
-    size: theme.iconSizes.medium
-  }) : createElement(CheckBoxOutlineBlankIcon, {
-    size: theme.iconSizes.medium
-  })), isTextVisuallyHidden ? createElement(HiddenLabelText, null, labelText) : textPosition !== CheckboxTextPosition.left && labelText && labelText)), !!errorMessage && createElement(InputMessage, {
+  }, checkboxIcon), isTextVisuallyHidden ? createElement(HiddenLabelText, null, labelText) : textPosition !== CheckboxTextPosition.left && labelText && labelText)), !!errorMessage && createElement(InputMessage, {
     id: descriptionId,
     hasError: true,
     isInverse: isInverse
@@ -8157,8 +8279,8 @@ function useDataPagination(props) {
 }
 
 var _excluded$F = ["columns", "components", "componentsProps", "defaultSelectedRows", "onHeaderSelect", "onRowSelect", "onSelectedRowsChange", "paginationProps", "rows", "selectedRows", "hasSquareCorners", "hasOutsideBorder", "hasPagination", "onSortBySelected", "sortDirection"],
-  _excluded2$1 = ["defaultPage"],
-  _excluded3 = ["field", "header"],
+  _excluded2$2 = ["defaultPage"],
+  _excluded3$1 = ["field", "header"],
   _excluded4 = ["id", "color", "isSelectableDisabled"];
 var Datagrid = /*#__PURE__*/forwardRef(function (props, ref) {
   var columns = props.columns,
@@ -8214,7 +8336,7 @@ var Datagrid = /*#__PURE__*/forwardRef(function (props, ref) {
   }, [currentPage, rowsPerPage]);
   var _defaultComponents = defaultComponents$1(_extends({}, customComponents)),
     Pagination = _defaultComponents.Pagination;
-  var passedOnPaginationProps = _objectWithoutPropertiesLoose(paginationProps, _excluded2$1);
+  var passedOnPaginationProps = _objectWithoutPropertiesLoose(paginationProps, _excluded2$2);
   passedOnPaginationProps.page = currentPage;
   passedOnPaginationProps.itemCount = rows.length;
   passedOnPaginationProps.rowsPerPage = rowsPerPage;
@@ -8270,7 +8392,7 @@ var Datagrid = /*#__PURE__*/forwardRef(function (props, ref) {
   }, columns.map(function (_ref) {
     var field = _ref.field,
       header = _ref.header,
-      other = _objectWithoutPropertiesLoose(_ref, _excluded3);
+      other = _objectWithoutPropertiesLoose(_ref, _excluded3$1);
     return createElement(TableHeaderCell, Object.assign({
       header: header,
       key: "headercell" + field
@@ -8442,7 +8564,7 @@ function rectToClientRect(rect) {
   };
 }
 
-var _excluded2$2 = ["mainAxis", "crossAxis", "fallbackPlacements", "fallbackStrategy", "fallbackAxisSideDirection", "flipAlignment"],
+var _excluded2$3 = ["mainAxis", "crossAxis", "fallbackPlacements", "fallbackStrategy", "fallbackAxisSideDirection", "flipAlignment"],
   _excluded4$1 = ["mainAxis", "crossAxis", "limiter"];
 function computeCoordsFromPlacement(_ref, placement, rtl) {
   var reference = _ref.reference,
@@ -8884,7 +9006,7 @@ var flip = function flip(options) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
               placement = state.placement, middlewareData = state.middlewareData, rects = state.rects, initialPlacement = state.initialPlacement, platform = state.platform, elements = state.elements;
-              _evaluate2 = evaluate(options, state), _evaluate2$mainAxis = _evaluate2.mainAxis, checkMainAxis = _evaluate2$mainAxis === void 0 ? true : _evaluate2$mainAxis, _evaluate2$crossAxis = _evaluate2.crossAxis, checkCrossAxis = _evaluate2$crossAxis === void 0 ? true : _evaluate2$crossAxis, specifiedFallbackPlacements = _evaluate2.fallbackPlacements, _evaluate2$fallbackSt = _evaluate2.fallbackStrategy, fallbackStrategy = _evaluate2$fallbackSt === void 0 ? 'bestFit' : _evaluate2$fallbackSt, _evaluate2$fallbackAx = _evaluate2.fallbackAxisSideDirection, fallbackAxisSideDirection = _evaluate2$fallbackAx === void 0 ? 'none' : _evaluate2$fallbackAx, _evaluate2$flipAlignm = _evaluate2.flipAlignment, flipAlignment = _evaluate2$flipAlignm === void 0 ? true : _evaluate2$flipAlignm, detectOverflowOptions = _objectWithoutPropertiesLoose(_evaluate2, _excluded2$2); // If a reset by the arrow was caused due to an alignment offset being
+              _evaluate2 = evaluate(options, state), _evaluate2$mainAxis = _evaluate2.mainAxis, checkMainAxis = _evaluate2$mainAxis === void 0 ? true : _evaluate2$mainAxis, _evaluate2$crossAxis = _evaluate2.crossAxis, checkCrossAxis = _evaluate2$crossAxis === void 0 ? true : _evaluate2$crossAxis, specifiedFallbackPlacements = _evaluate2.fallbackPlacements, _evaluate2$fallbackSt = _evaluate2.fallbackStrategy, fallbackStrategy = _evaluate2$fallbackSt === void 0 ? 'bestFit' : _evaluate2$fallbackSt, _evaluate2$fallbackAx = _evaluate2.fallbackAxisSideDirection, fallbackAxisSideDirection = _evaluate2$fallbackAx === void 0 ? 'none' : _evaluate2$fallbackAx, _evaluate2$flipAlignm = _evaluate2.flipAlignment, flipAlignment = _evaluate2$flipAlignm === void 0 ? true : _evaluate2$flipAlignm, detectOverflowOptions = _objectWithoutPropertiesLoose(_evaluate2, _excluded2$3); // If a reset by the arrow was caused due to an alignment offset being
               // added, we should skip any logic now since `flip()` has already done its
               // work.
               // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
@@ -10404,7 +10526,7 @@ var CalendarContext = /*#__PURE__*/createContext({
   setYearFocusedDate: function setYearFocusedDate(yearNumber) {}
 });
 
-var _excluded3$1 = ["transform"],
+var _excluded3$2 = ["transform"],
   _excluded4$2 = ["context", "width", "height", "tipRadius", "strokeWidth", "staticOffset", "stroke", "d", "style"];
 
 // https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379
@@ -10534,7 +10656,7 @@ var FloatingArrow = /*#__PURE__*/forwardRef(function FloatingArrow(props, ref) {
     _props$style = props.style,
     _props$style2 = _props$style === void 0 ? {} : _props$style,
     transform = _props$style2.transform,
-    restStyle = _objectWithoutPropertiesLoose(_props$style2, _excluded3$1),
+    restStyle = _objectWithoutPropertiesLoose(_props$style2, _excluded3$2),
     rest = _objectWithoutPropertiesLoose(props, _excluded4$2);
   if (process.env.NODE_ENV !== "production") {
     if (!ref) {
@@ -12777,7 +12899,7 @@ function getNative(object, key) {
 }
 
 /* Built-in method references that are verified to be native. */
-var WeakMap = /*#__PURE__*/getNative(root, 'WeakMap');
+var WeakMap$1 = /*#__PURE__*/getNative(root, 'WeakMap');
 
 /** Used as references for various `Number` constants. */
 var MAX_SAFE_INTEGER = 9007199254740991;
@@ -13126,7 +13248,7 @@ var dataViewCtorString = /*#__PURE__*/toSource(DataView),
   mapCtorString = /*#__PURE__*/toSource(Map$1),
   promiseCtorString = /*#__PURE__*/toSource(Promise$1),
   setCtorString = /*#__PURE__*/toSource(Set$1),
-  weakMapCtorString = /*#__PURE__*/toSource(WeakMap);
+  weakMapCtorString = /*#__PURE__*/toSource(WeakMap$1);
 
 /**
  * Gets the `toStringTag` of `value`.
@@ -13138,7 +13260,7 @@ var dataViewCtorString = /*#__PURE__*/toSource(DataView),
 var getTag = baseGetTag;
 
 // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
-if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$1 || Map$1 && getTag(new Map$1()) != mapTag$1 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$1 || WeakMap && getTag(new WeakMap()) != weakMapTag$1) {
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$1 || Map$1 && getTag(new Map$1()) != mapTag$1 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$1 || WeakMap$1 && getTag(new WeakMap$1()) != weakMapTag$1) {
   getTag = function getTag(value) {
     var result = baseGetTag(value),
       Ctor = result == objectTag$1 ? value.constructor : undefined,
@@ -17951,7 +18073,7 @@ var Tabs = /*#__PURE__*/React__default.forwardRef(function (props, ref) {
 });
 
 var _excluded$1b = ["children", "icon", "disabled", "testId", "unstyled"],
-  _excluded2$3 = ["borderPosition", "buttonRefArray", "changeHandler", "iconPosition", "isFullWidth", "isInverse", "orientation", "registerTabButton", "textTransform"];
+  _excluded2$4 = ["borderPosition", "buttonRefArray", "changeHandler", "iconPosition", "isFullWidth", "isInverse", "orientation", "registerTabButton", "textTransform"];
 var StyledTabsChild = /*#__PURE__*/_styled('li', {
   shouldForwardProp: isPropValid,
   target: "e1ym35js2",
@@ -18078,7 +18200,7 @@ var Tab = /*#__PURE__*/React__default.forwardRef(function (props, forwardedRef)
   var panelId = "tabpanel-" + instanceId + "-" + index;
   if (unstyled) {
     var child = React__default.Children.only(children);
-    var clonedElProps = _objectWithoutPropertiesLoose(rest, _excluded2$3);
+    var clonedElProps = _objectWithoutPropertiesLoose(rest, _excluded2$4);
     return React__default.createElement(StyledTabsChild, {
       borderPosition: borderPosition,
       "data-testid": "tabContainer",
@@ -18343,7 +18465,7 @@ var TabScrollSpyPanel = /*#__PURE__*/React__default.forwardRef(function (props,
 });
 
 var _excluded$1g = ["children", "component", "icon", "style", "onClick"],
-  _excluded2$4 = ["isActive", "icon", "isFocused", "testId", "to"];
+  _excluded2$5 = ["isActive", "icon", "isFocused", "testId", "to"];
 function instanceOfNavComponentTab(object) {
   return 'component' in object && !('children' in object);
 }
@@ -18388,7 +18510,7 @@ var NavTab = /*#__PURE__*/forwardRef(function (props, forwardRef) {
     isFocused = resolvedProps.isFocused,
     testId = resolvedProps.testId,
     to = resolvedProps.to,
-    other = _objectWithoutPropertiesLoose(resolvedProps, _excluded2$4);
+    other = _objectWithoutPropertiesLoose(resolvedProps, _excluded2$5);
   var theme = useContext(ThemeContext);
   if (instanceOfNavComponentTab(props)) {
     component = props.component;
@@ -18827,7 +18949,7 @@ var SimplePagination = /*#__PURE__*/forwardRef(function (props, ref) {
 });
 
 var _excluded$1k = ["count", "defaultPage", "disabled", "hideNextButton", "hidePreviousButton", "isInverse", "numberOfAdjacentPages", "numberOfEdgePages", "page", "size", "showFirstButton", "showLastButton", "type", "testId", "onPageChange"],
-  _excluded2$5 = ["aria-current", "page", "type", "isSelected"];
+  _excluded2$6 = ["aria-current", "page", "type", "isSelected"];
 function _EMOTION_STRINGIFIED_CSS_ERROR__$z() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
 var PaginationType;
 (function (PaginationType) {
@@ -18964,7 +19086,7 @@ var Pagination = /*#__PURE__*/forwardRef(function (props, ref) {
       page = _ref.page,
       type = _ref.type,
       isSelected = _ref.isSelected,
-      other = _objectWithoutPropertiesLoose(_ref, _excluded2$5);
+      other = _objectWithoutPropertiesLoose(_ref, _excluded2$6);
     if (type === 'start-ellipsis' || type === 'end-ellipsis') {
       return createElement(StyledEllipsis, {
         "aria-current": Boolean(ariaCurrent),
@@ -19714,7 +19836,7 @@ var setFocusedItem = function setFocusedItem(step, highlightedIndex, items, setH
 };
 
 var _excluded$1q = ["customComponents", "floatingElementStyles", "getItemProps", "getMenuProps", "highlightedIndex", "isInverse", "isLoading", "isOpen", "items", "itemToString", "maxHeight", "menuStyle", "setFloating", "setHighlightedIndex", "selectedItem"],
-  _excluded2$6 = ["ref"];
+  _excluded2$7 = ["ref"];
 function _EMOTION_STRINGIFIED_CSS_ERROR__$A() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
 var NoItemsMessage = /*#__PURE__*/_styled("span", {
   target: "e8oncro1",
@@ -19826,7 +19948,7 @@ function ItemsList(props) {
         disabled: isDisabled
       }),
       ref = _getItemProps.ref,
-      otherDownshiftItemProps = _objectWithoutPropertiesLoose(_getItemProps, _excluded2$6);
+      otherDownshiftItemProps = _objectWithoutPropertiesLoose(_getItemProps, _excluded2$7);
     var key = "" + itemString + index;
     var isSelected = selectedItem === itemToString(item);
     var itemProps = _extends({
@@ -21144,7 +21266,7 @@ function InternalCombobox(props) {
 }
 
 var _excluded$1t = ["react_magma__created_item"],
-  _excluded2$7 = ["stateReducer", "onStateChange"];
+  _excluded2$8 = ["stateReducer", "onStateChange"];
 function MultiCombobox(props) {
   var _i18n$combobox$multi2, _i18n$combobox, _clearIndicatori18n$r, _i18n$combobox$multi3, _i18n$combobox$multi4;
   var _React$useState = useState(''),
@@ -21270,7 +21392,7 @@ function MultiCombobox(props) {
       setInputValue('');
     }
   }
-  var comboboxProps = _objectWithoutPropertiesLoose(props, _excluded2$7);
+  var comboboxProps = _objectWithoutPropertiesLoose(props, _excluded2$8);
   function handleOnIsOpenChange(changes) {
     var changedIsOpen = changes.isOpen;
     if (!changedIsOpen) {
@@ -23274,7 +23396,7 @@ var PopoverTrigger = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
 });
 
 var _excluded$1F = ["children", "style"],
-  _excluded2$8 = ["children", "style"];
+  _excluded2$9 = ["children", "style"];
 function _EMOTION_STRINGIFIED_CSS_ERROR__$F() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
 var SectionEnum;
 (function (SectionEnum) {
@@ -23357,7 +23479,7 @@ var PopoverHeader = function PopoverHeader(_ref3) {
 var PopoverFooter = function PopoverFooter(_ref4) {
   var children = _ref4.children,
     style = _ref4.style,
-    other = _objectWithoutPropertiesLoose(_ref4, _excluded2$8);
+    other = _objectWithoutPropertiesLoose(_ref4, _excluded2$9);
   return React__default.createElement(PopoverSection, Object.assign({
     section: SectionEnum.footer,
     style: style