@norges-domstoler/dds-components 0.0.0-dev-20240605061318 → 0.0.0-dev-20240605101112

package/dist/index.js

@@ -6,15 +6,18 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -28,6 +31,44 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/shallowequal@1.1.0/node_modules/shallowequal/index.js
+var require_shallowequal = __commonJS({
+  "../../node_modules/.pnpm/shallowequal@1.1.0/node_modules/shallowequal/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function shallowEqual(objA, objB, compare, compareContext) {
+      var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
+      if (ret !== void 0) {
+        return !!ret;
+      }
+      if (objA === objB) {
+        return true;
+      }
+      if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
+        return false;
+      }
+      var keysA = Object.keys(objA);
+      var keysB = Object.keys(objB);
+      if (keysA.length !== keysB.length) {
+        return false;
+      }
+      var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+      for (var idx = 0; idx < keysA.length; idx++) {
+        var key = keysA[idx];
+        if (!bHasOwnProperty(key)) {
+          return false;
+        }
+        var valueA = objA[key];
+        var valueB = objB[key];
+        ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
+        if (ret === false || ret === void 0 && valueA !== valueB) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -531,7 +572,7 @@ var getFormInputIconSize = (componentSize) => {
 };
 
 // src/utils/idGenerator.tsx
-var derivativeIdGenerator = (prefix2, suffix) => `${prefix2}-${suffix}`;
+var derivativeIdGenerator = (prefix3, suffix) => `${prefix3}-${suffix}`;
 var spaceSeparatedIdListGenerator = (values) => {
   const filtered = values.filter(Boolean);
   return filtered.length > 0 ? filtered.join(" ") : void 0;
@@ -2433,7 +2474,7 @@ var useFloatPosition = (arrowRef, options = {}) => {
     offset = defaultOffset,
     placement = "bottom"
   } = options;
-  const middleware = [
+  const middleware2 = [
     (0, import_react_dom.offset)(offset),
     (0, import_react_dom.flip)(),
     (0, import_react_dom.shift)(),
@@ -2441,15 +2482,15 @@ var useFloatPosition = (arrowRef, options = {}) => {
     ...arrowRef ? [(0, import_react_dom.arrow)({ element: arrowRef })] : []
   ];
   const {
-    x,
-    y,
+    x: x2,
+    y: y2,
     strategy,
     middlewareData,
     placement: actualPlacement,
     refs
   } = (0, import_react_dom.useFloating)({
     placement,
-    middleware,
+    middleware: middleware2,
     whileElementsMounted: (reference, floating, update) => (0, import_react_dom.autoUpdate)(reference, floating, update, { animationFrame })
   });
   return {
@@ -2457,8 +2498,8 @@ var useFloatPosition = (arrowRef, options = {}) => {
     styles: {
       floating: {
         position: strategy,
-        top: y != null ? y : "",
-        left: x != null ? x : ""
+        top: y2 != null ? y2 : "",
+        left: x2 != null ? x2 : ""
       },
       arrow: middlewareData.arrow ? getArrowStyling(strategy, actualPlacement, middlewareData.arrow) : void 0
     }
@@ -2655,12 +2696,12 @@ function useRoveFocus(size2, active, direction = "column") {
       if (!size2 || !isKeyboardEvent(e)) return;
       if (e.key === nextKey) {
         e.preventDefault();
-        setCurrentFocusIndex((prev) => prev === size2 - 1 ? 0 : prev + 1);
+        setCurrentFocusIndex((prev2) => prev2 === size2 - 1 ? 0 : prev2 + 1);
       } else if (e.key === previousKey) {
         e.preventDefault();
-        setCurrentFocusIndex((prev) => {
-          if (prev === -1 || prev === 0) return size2 - 1;
-          return prev - 1;
+        setCurrentFocusIndex((prev2) => {
+          if (prev2 === -1 || prev2 === 0) return size2 - 1;
+          return prev2 - 1;
         });
       }
     },
@@ -3127,10 +3168,1262 @@ var selection = {
   backgroundColor: import_dds_design_tokens10.ddsTokens.DdsColorSurfaceHighlightedDefault
 };
 
+// ../../node_modules/.pnpm/tslib@2.6.2/node_modules/tslib/tslib.es6.mjs
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s2, i2 = 1, n = arguments.length; i2 < n; i2++) {
+      s2 = arguments[i2];
+      for (var p2 in s2) if (Object.prototype.hasOwnProperty.call(s2, p2)) t[p2] = s2[p2];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __spreadArray(to, from2, pack) {
+  if (pack || arguments.length === 2) for (var i2 = 0, l2 = from2.length, ar; i2 < l2; i2++) {
+    if (ar || !(i2 in from2)) {
+      if (!ar) ar = Array.prototype.slice.call(from2, 0, i2);
+      ar[i2] = from2[i2];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from2));
+}
+
+// ../../node_modules/.pnpm/@emotion+memoize@0.8.1/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
+function memoize(fn) {
+  var cache = /* @__PURE__ */ Object.create(null);
+  return function(arg) {
+    if (cache[arg] === void 0) cache[arg] = fn(arg);
+    return cache[arg];
+  };
+}
+
+// ../../node_modules/.pnpm/@emotion+is-prop-valid@1.2.2/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js
+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|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)-.*))$/;
+var isPropValid = /* @__PURE__ */ memoize(
+  function(prop) {
+    return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111 && prop.charCodeAt(1) === 110 && prop.charCodeAt(2) < 91;
+  }
+  /* Z+1 */
+);
+
+// ../../node_modules/.pnpm/styled-components@6.1.11_react-dom@18.3.1_react@18.3.1/node_modules/styled-components/dist/styled-components.esm.js
+var import_react21 = __toESM(require("react"));
+var import_shallowequal = __toESM(require_shallowequal());
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Enum.js
+var MS = "-ms-";
+var MOZ = "-moz-";
+var WEBKIT = "-webkit-";
+var COMMENT = "comm";
+var RULESET = "rule";
+var DECLARATION = "decl";
+var IMPORT = "@import";
+var KEYFRAMES = "@keyframes";
+var LAYER = "@layer";
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Utility.js
+var abs = Math.abs;
+var from = String.fromCharCode;
+var assign = Object.assign;
+function hash(value, length2) {
+  return charat(value, 0) ^ 45 ? (((length2 << 2 ^ charat(value, 0)) << 2 ^ charat(value, 1)) << 2 ^ charat(value, 2)) << 2 ^ charat(value, 3) : 0;
+}
+function trim(value) {
+  return value.trim();
+}
+function match(value, pattern) {
+  return (value = pattern.exec(value)) ? value[0] : value;
+}
+function replace(value, pattern, replacement) {
+  return value.replace(pattern, replacement);
+}
+function indexof(value, search, position2) {
+  return value.indexOf(search, position2);
+}
+function charat(value, index) {
+  return value.charCodeAt(index) | 0;
+}
+function substr(value, begin, end) {
+  return value.slice(begin, end);
+}
+function strlen(value) {
+  return value.length;
+}
+function sizeof(value) {
+  return value.length;
+}
+function append(value, array) {
+  return array.push(value), value;
+}
+function combine(array, callback) {
+  return array.map(callback).join("");
+}
+function filter(array, pattern) {
+  return array.filter(function(value) {
+    return !match(value, pattern);
+  });
+}
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Tokenizer.js
+var line = 1;
+var column = 1;
+var length = 0;
+var position = 0;
+var character = 0;
+var characters = "";
+function node(value, root, parent, type, props, children, length2, siblings) {
+  return { value, root, parent, type, props, children, line, column, length: length2, return: "", siblings };
+}
+function copy(root, props) {
+  return assign(node("", null, null, "", null, null, 0, root.siblings), root, { length: -root.length }, props);
+}
+function lift(root) {
+  while (root.root)
+    root = copy(root.root, { children: [root] });
+  append(root, root.siblings);
+}
+function char() {
+  return character;
+}
+function prev() {
+  character = position > 0 ? charat(characters, --position) : 0;
+  if (column--, character === 10)
+    column = 1, line--;
+  return character;
+}
+function next() {
+  character = position < length ? charat(characters, position++) : 0;
+  if (column++, character === 10)
+    column = 1, line++;
+  return character;
+}
+function peek() {
+  return charat(characters, position);
+}
+function caret() {
+  return position;
+}
+function slice(begin, end) {
+  return substr(characters, begin, end);
+}
+function token(type) {
+  switch (type) {
+    case 0:
+    case 9:
+    case 10:
+    case 13:
+    case 32:
+      return 5;
+    case 33:
+    case 43:
+    case 44:
+    case 47:
+    case 62:
+    case 64:
+    case 126:
+    case 59:
+    case 123:
+    case 125:
+      return 4;
+    case 58:
+      return 3;
+    case 34:
+    case 39:
+    case 40:
+    case 91:
+      return 2;
+    case 41:
+    case 93:
+      return 1;
+  }
+  return 0;
+}
+function alloc(value) {
+  return line = column = 1, length = strlen(characters = value), position = 0, [];
+}
+function dealloc(value) {
+  return characters = "", value;
+}
+function delimit(type) {
+  return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
+}
+function whitespace(type) {
+  while (character = peek())
+    if (character < 33)
+      next();
+    else
+      break;
+  return token(type) > 2 || token(character) > 3 ? "" : " ";
+}
+function escaping(index, count) {
+  while (--count && next())
+    if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97)
+      break;
+  return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32));
+}
+function delimiter(type) {
+  while (next())
+    switch (character) {
+      case type:
+        return position;
+      case 34:
+      case 39:
+        if (type !== 34 && type !== 39)
+          delimiter(character);
+        break;
+      case 40:
+        if (type === 41)
+          delimiter(type);
+        break;
+      case 92:
+        next();
+        break;
+    }
+  return position;
+}
+function commenter(type, index) {
+  while (next())
+    if (type + character === 47 + 10)
+      break;
+    else if (type + character === 42 + 42 && peek() === 47)
+      break;
+  return "/*" + slice(index, position - 1) + "*" + from(type === 47 ? type : next());
+}
+function identifier(index) {
+  while (!token(peek()))
+    next();
+  return slice(index, position);
+}
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Parser.js
+function compile(value) {
+  return dealloc(parse("", null, null, null, [""], value = alloc(value), 0, [0], value));
+}
+function parse(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+  var index = 0;
+  var offset = 0;
+  var length2 = pseudo;
+  var atrule = 0;
+  var property = 0;
+  var previous = 0;
+  var variable = 1;
+  var scanning = 1;
+  var ampersand = 1;
+  var character2 = 0;
+  var type = "";
+  var props = rules;
+  var children = rulesets;
+  var reference = rule;
+  var characters2 = type;
+  while (scanning)
+    switch (previous = character2, character2 = next()) {
+      case 40:
+        if (previous != 108 && charat(characters2, length2 - 1) == 58) {
+          if (indexof(characters2 += replace(delimit(character2), "&", "&\f"), "&\f", abs(index ? points[index - 1] : 0)) != -1)
+            ampersand = -1;
+          break;
+        }
+      case 34:
+      case 39:
+      case 91:
+        characters2 += delimit(character2);
+        break;
+      case 9:
+      case 10:
+      case 13:
+      case 32:
+        characters2 += whitespace(previous);
+        break;
+      case 92:
+        characters2 += escaping(caret() - 1, 7);
+        continue;
+      case 47:
+        switch (peek()) {
+          case 42:
+          case 47:
+            append(comment(commenter(next(), caret()), root, parent, declarations), declarations);
+            break;
+          default:
+            characters2 += "/";
+        }
+        break;
+      case 123 * variable:
+        points[index++] = strlen(characters2) * ampersand;
+      case 125 * variable:
+      case 59:
+      case 0:
+        switch (character2) {
+          case 0:
+          case 125:
+            scanning = 0;
+          case 59 + offset:
+            if (ampersand == -1) characters2 = replace(characters2, /\f/g, "");
+            if (property > 0 && strlen(characters2) - length2)
+              append(property > 32 ? declaration(characters2 + ";", rule, parent, length2 - 1, declarations) : declaration(replace(characters2, " ", "") + ";", rule, parent, length2 - 2, declarations), declarations);
+            break;
+          case 59:
+            characters2 += ";";
+          default:
+            append(reference = ruleset(characters2, root, parent, index, offset, rules, points, type, props = [], children = [], length2, rulesets), rulesets);
+            if (character2 === 123)
+              if (offset === 0)
+                parse(characters2, root, reference, reference, props, rulesets, length2, points, children);
+              else
+                switch (atrule === 99 && charat(characters2, 3) === 110 ? 100 : atrule) {
+                  case 100:
+                  case 108:
+                  case 109:
+                  case 115:
+                    parse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length2, children), children), rules, children, length2, points, rule ? props : children);
+                    break;
+                  default:
+                    parse(characters2, reference, reference, reference, [""], children, 0, points, children);
+                }
+        }
+        index = offset = property = 0, variable = ampersand = 1, type = characters2 = "", length2 = pseudo;
+        break;
+      case 58:
+        length2 = 1 + strlen(characters2), property = previous;
+      default:
+        if (variable < 1) {
+          if (character2 == 123)
+            --variable;
+          else if (character2 == 125 && variable++ == 0 && prev() == 125)
+            continue;
+        }
+        switch (characters2 += from(character2), character2 * variable) {
+          case 38:
+            ampersand = offset > 0 ? 1 : (characters2 += "\f", -1);
+            break;
+          case 44:
+            points[index++] = (strlen(characters2) - 1) * ampersand, ampersand = 1;
+            break;
+          case 64:
+            if (peek() === 45)
+              characters2 += delimit(next());
+            atrule = peek(), offset = length2 = strlen(type = characters2 += identifier(caret())), character2++;
+            break;
+          case 45:
+            if (previous === 45 && strlen(characters2) == 2)
+              variable = 0;
+        }
+    }
+  return rulesets;
+}
+function ruleset(value, root, parent, index, offset, rules, points, type, props, children, length2, siblings) {
+  var post = offset - 1;
+  var rule = offset === 0 ? rules : [""];
+  var size2 = sizeof(rule);
+  for (var i2 = 0, j2 = 0, k2 = 0; i2 < index; ++i2)
+    for (var x2 = 0, y2 = substr(value, post + 1, post = abs(j2 = points[i2])), z2 = value; x2 < size2; ++x2)
+      if (z2 = trim(j2 > 0 ? rule[x2] + " " + y2 : replace(y2, /&\f/g, rule[x2])))
+        props[k2++] = z2;
+  return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length2, siblings);
+}
+function comment(value, root, parent, siblings) {
+  return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0, siblings);
+}
+function declaration(value, root, parent, length2, siblings) {
+  return node(value, root, parent, DECLARATION, substr(value, 0, length2), substr(value, length2 + 1, -1), length2, siblings);
+}
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Prefixer.js
+function prefix(value, length2, children) {
+  switch (hash(value, length2)) {
+    case 5103:
+      return WEBKIT + "print-" + value + value;
+    case 5737:
+    case 4201:
+    case 3177:
+    case 3433:
+    case 1641:
+    case 4457:
+    case 2921:
+    case 5572:
+    case 6356:
+    case 5844:
+    case 3191:
+    case 6645:
+    case 3005:
+    case 6391:
+    case 5879:
+    case 5623:
+    case 6135:
+    case 4599:
+    case 4855:
+    case 4215:
+    case 6389:
+    case 5109:
+    case 5365:
+    case 5621:
+    case 3829:
+      return WEBKIT + value + value;
+    case 4789:
+      return MOZ + value + value;
+    case 5349:
+    case 4246:
+    case 4810:
+    case 6968:
+    case 2756:
+      return WEBKIT + value + MOZ + value + MS + value + value;
+    case 5936:
+      switch (charat(value, length2 + 11)) {
+        case 114:
+          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, "tb") + value;
+        case 108:
+          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, "tb-rl") + value;
+        case 45:
+          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, "lr") + value;
+      }
+    case 6828:
+    case 4268:
+    case 2903:
+      return WEBKIT + value + MS + value + value;
+    case 6165:
+      return WEBKIT + value + MS + "flex-" + value + value;
+    case 5187:
+      return WEBKIT + value + replace(value, /(\w+).+(:[^]+)/, WEBKIT + "box-$1$2" + MS + "flex-$1$2") + value;
+    case 5443:
+      return WEBKIT + value + MS + "flex-item-" + replace(value, /flex-|-self/g, "") + (!match(value, /flex-|baseline/) ? MS + "grid-row-" + replace(value, /flex-|-self/g, "") : "") + value;
+    case 4675:
+      return WEBKIT + value + MS + "flex-line-pack" + replace(value, /align-content|flex-|-self/g, "") + value;
+    case 5548:
+      return WEBKIT + value + MS + replace(value, "shrink", "negative") + value;
+    case 5292:
+      return WEBKIT + value + MS + replace(value, "basis", "preferred-size") + value;
+    case 6060:
+      return WEBKIT + "box-" + replace(value, "-grow", "") + WEBKIT + value + MS + replace(value, "grow", "positive") + value;
+    case 4554:
+      return WEBKIT + replace(value, /([^-])(transform)/g, "$1" + WEBKIT + "$2") + value;
+    case 6187:
+      return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + "$1"), /(image-set)/, WEBKIT + "$1"), value, "") + value;
+    case 5495:
+    case 3959:
+      return replace(value, /(image-set\([^]*)/, WEBKIT + "$1$`$1");
+    case 4968:
+      return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + "box-pack:$3" + MS + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + WEBKIT + value + value;
+    case 4200:
+      if (!match(value, /flex-|baseline/)) return MS + "grid-column-align" + substr(value, length2) + value;
+      break;
+    case 2592:
+    case 3360:
+      return MS + replace(value, "template-", "") + value;
+    case 4384:
+    case 3616:
+      if (children && children.some(function(element, index) {
+        return length2 = index, match(element.props, /grid-\w+-end/);
+      })) {
+        return ~indexof(value + (children = children[length2].value), "span", 0) ? value : MS + replace(value, "-start", "") + value + MS + "grid-row-span:" + (~indexof(children, "span", 0) ? match(children, /\d+/) : +match(children, /\d+/) - +match(value, /\d+/)) + ";";
+      }
+      return MS + replace(value, "-start", "") + value;
+    case 4896:
+    case 4128:
+      return children && children.some(function(element) {
+        return match(element.props, /grid-\w+-start/);
+      }) ? value : MS + replace(replace(value, "-end", "-span"), "span ", "") + value;
+    case 4095:
+    case 3583:
+    case 4068:
+    case 2532:
+      return replace(value, /(.+)-inline(.+)/, WEBKIT + "$1$2") + value;
+    case 8116:
+    case 7059:
+    case 5753:
+    case 5535:
+    case 5445:
+    case 5701:
+    case 4933:
+    case 4677:
+    case 5533:
+    case 5789:
+    case 5021:
+    case 4765:
+      if (strlen(value) - 1 - length2 > 6)
+        switch (charat(value, length2 + 1)) {
+          case 109:
+            if (charat(value, length2 + 4) !== 45)
+              break;
+          case 102:
+            return replace(value, /(.+:)(.+)-([^]+)/, "$1" + WEBKIT + "$2-$3$1" + MOZ + (charat(value, length2 + 3) == 108 ? "$3" : "$2-$3")) + value;
+          case 115:
+            return ~indexof(value, "stretch", 0) ? prefix(replace(value, "stretch", "fill-available"), length2, children) + value : value;
+        }
+      break;
+    case 5152:
+    case 5920:
+      return replace(value, /(.+?):(\d+)(\s*\/\s*(span)?\s*(\d+))?(.*)/, function(_2, a3, b, c2, d, e, f2) {
+        return MS + a3 + ":" + b + f2 + (c2 ? MS + a3 + "-span:" + (d ? e : +e - +b) + f2 : "") + value;
+      });
+    case 4949:
+      if (charat(value, length2 + 6) === 121)
+        return replace(value, ":", ":" + WEBKIT) + value;
+      break;
+    case 6444:
+      switch (charat(value, charat(value, 14) === 45 ? 18 : 11)) {
+        case 120:
+          return replace(value, /(.+:)([^;\s!]+)(;|(\s+)?!.+)?/, "$1" + WEBKIT + (charat(value, 14) === 45 ? "inline-" : "") + "box$3$1" + WEBKIT + "$2$3$1" + MS + "$2box$3") + value;
+        case 100:
+          return replace(value, ":", ":" + MS) + value;
+      }
+      break;
+    case 5719:
+    case 2647:
+    case 2135:
+    case 3927:
+    case 2391:
+      return replace(value, "scroll-", "scroll-snap-") + value;
+  }
+  return value;
+}
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Serializer.js
+function serialize(children, callback) {
+  var output = "";
+  for (var i2 = 0; i2 < children.length; i2++)
+    output += callback(children[i2], i2, children, callback) || "";
+  return output;
+}
+function stringify(element, index, children, callback) {
+  switch (element.type) {
+    case LAYER:
+      if (element.children.length) break;
+    case IMPORT:
+    case DECLARATION:
+      return element.return = element.return || element.value;
+    case COMMENT:
+      return "";
+    case KEYFRAMES:
+      return element.return = element.value + "{" + serialize(element.children, callback) + "}";
+    case RULESET:
+      if (!strlen(element.value = element.props.join(","))) return "";
+  }
+  return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
+}
+
+// ../../node_modules/.pnpm/stylis@4.3.2/node_modules/stylis/src/Middleware.js
+function middleware(collection) {
+  var length2 = sizeof(collection);
+  return function(element, index, children, callback) {
+    var output = "";
+    for (var i2 = 0; i2 < length2; i2++)
+      output += collection[i2](element, index, children, callback) || "";
+    return output;
+  };
+}
+function rulesheet(callback) {
+  return function(element) {
+    if (!element.root) {
+      if (element = element.return)
+        callback(element);
+    }
+  };
+}
+function prefixer(element, index, children, callback) {
+  if (element.length > -1) {
+    if (!element.return)
+      switch (element.type) {
+        case DECLARATION:
+          element.return = prefix(element.value, element.length, children);
+          return;
+        case KEYFRAMES:
+          return serialize([copy(element, { value: replace(element.value, "@", "@" + WEBKIT) })], callback);
+        case RULESET:
+          if (element.length)
+            return combine(children = element.props, function(value) {
+              switch (match(value, callback = /(::plac\w+|:read-\w+)/)) {
+                case ":read-only":
+                case ":read-write":
+                  lift(copy(element, { props: [replace(value, /:(read-\w+)/, ":" + MOZ + "$1")] }));
+                  lift(copy(element, { props: [value] }));
+                  assign(element, { props: filter(children, callback) });
+                  break;
+                case "::placeholder":
+                  lift(copy(element, { props: [replace(value, /:(plac\w+)/, ":" + WEBKIT + "input-$1")] }));
+                  lift(copy(element, { props: [replace(value, /:(plac\w+)/, ":" + MOZ + "$1")] }));
+                  lift(copy(element, { props: [replace(value, /:(plac\w+)/, MS + "input-$1")] }));
+                  lift(copy(element, { props: [value] }));
+                  assign(element, { props: filter(children, callback) });
+                  break;
+              }
+              return "";
+            });
+      }
+  }
+}
+
+// ../../node_modules/.pnpm/@emotion+unitless@0.8.1/node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
+var unitlessKeys = {
+  animationIterationCount: 1,
+  aspectRatio: 1,
+  borderImageOutset: 1,
+  borderImageSlice: 1,
+  borderImageWidth: 1,
+  boxFlex: 1,
+  boxFlexGroup: 1,
+  boxOrdinalGroup: 1,
+  columnCount: 1,
+  columns: 1,
+  flex: 1,
+  flexGrow: 1,
+  flexPositive: 1,
+  flexShrink: 1,
+  flexNegative: 1,
+  flexOrder: 1,
+  gridRow: 1,
+  gridRowEnd: 1,
+  gridRowSpan: 1,
+  gridRowStart: 1,
+  gridColumn: 1,
+  gridColumnEnd: 1,
+  gridColumnSpan: 1,
+  gridColumnStart: 1,
+  msGridRow: 1,
+  msGridRowSpan: 1,
+  msGridColumn: 1,
+  msGridColumnSpan: 1,
+  fontWeight: 1,
+  lineHeight: 1,
+  opacity: 1,
+  order: 1,
+  orphans: 1,
+  tabSize: 1,
+  widows: 1,
+  zIndex: 1,
+  zoom: 1,
+  WebkitLineClamp: 1,
+  // SVG-related properties
+  fillOpacity: 1,
+  floodOpacity: 1,
+  stopOpacity: 1,
+  strokeDasharray: 1,
+  strokeDashoffset: 1,
+  strokeMiterlimit: 1,
+  strokeOpacity: 1,
+  strokeWidth: 1
+};
+
+// ../../node_modules/.pnpm/styled-components@6.1.11_react-dom@18.3.1_react@18.3.1/node_modules/styled-components/dist/styled-components.esm.js
+var f = "undefined" != typeof process && void 0 !== process.env && (process.env.REACT_APP_SC_ATTR || process.env.SC_ATTR) || "data-styled";
+var m = "active";
+var y = "data-styled-version";
+var v = "6.1.11";
+var g = "/*!sc*/\n";
+var S = "undefined" != typeof window && "HTMLElement" in window;
+var w = Boolean("boolean" == typeof SC_DISABLE_SPEEDY ? SC_DISABLE_SPEEDY : "undefined" != typeof process && void 0 !== process.env && void 0 !== process.env.REACT_APP_SC_DISABLE_SPEEDY && "" !== process.env.REACT_APP_SC_DISABLE_SPEEDY ? "false" !== process.env.REACT_APP_SC_DISABLE_SPEEDY && process.env.REACT_APP_SC_DISABLE_SPEEDY : "undefined" != typeof process && void 0 !== process.env && void 0 !== process.env.SC_DISABLE_SPEEDY && "" !== process.env.SC_DISABLE_SPEEDY ? "false" !== process.env.SC_DISABLE_SPEEDY && process.env.SC_DISABLE_SPEEDY : "production" !== process.env.NODE_ENV);
+var E = /invalid hook call/i;
+var N = /* @__PURE__ */ new Set();
+var P = function(t, n) {
+  if ("production" !== process.env.NODE_ENV) {
+    var o2 = n ? ' with the id of "'.concat(n, '"') : "", s2 = "The component ".concat(t).concat(o2, " has been created dynamically.\n") + "You may see this warning because you've called styled inside another component.\nTo resolve this only create new StyledComponents outside of any render method and function component.", i2 = console.error;
+    try {
+      var a3 = true;
+      console.error = function(t2) {
+        for (var n2 = [], o3 = 1; o3 < arguments.length; o3++) n2[o3 - 1] = arguments[o3];
+        E.test(t2) ? (a3 = false, N.delete(s2)) : i2.apply(void 0, __spreadArray([t2], n2, false));
+      }, (0, import_react21.useRef)(), a3 && !N.has(s2) && (console.warn(s2), N.add(s2));
+    } catch (e) {
+      E.test(e.message) && N.delete(s2);
+    } finally {
+      console.error = i2;
+    }
+  }
+};
+var _ = Object.freeze([]);
+var C = Object.freeze({});
+function I(e, t, n) {
+  return void 0 === n && (n = C), e.theme !== n.theme && e.theme || t || n.theme;
+}
+var A = /* @__PURE__ */ new Set(["a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "big", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "keygen", "label", "legend", "li", "link", "main", "map", "mark", "menu", "menuitem", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "section", "select", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "u", "ul", "use", "var", "video", "wbr", "circle", "clipPath", "defs", "ellipse", "foreignObject", "g", "image", "line", "linearGradient", "marker", "mask", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "stop", "svg", "text", "tspan"]);
+var O = /[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~-]+/g;
+var D = /(^-|-$)/g;
+function R(e) {
+  return e.replace(O, "-").replace(D, "");
+}
+var T = /(a)(d)/gi;
+var k = 52;
+var j = function(e) {
+  return String.fromCharCode(e + (e > 25 ? 39 : 97));
+};
+function x(e) {
+  var t, n = "";
+  for (t = Math.abs(e); t > k; t = t / k | 0) n = j(t % k) + n;
+  return (j(t % k) + n).replace(T, "$1-$2");
+}
+var V;
+var F = 5381;
+var M = function(e, t) {
+  for (var n = t.length; n; ) e = 33 * e ^ t.charCodeAt(--n);
+  return e;
+};
+var z = function(e) {
+  return M(F, e);
+};
+function $(e) {
+  return x(z(e) >>> 0);
+}
+function B(e) {
+  return "production" !== process.env.NODE_ENV && "string" == typeof e && e || e.displayName || e.name || "Component";
+}
+function L(e) {
+  return "string" == typeof e && ("production" === process.env.NODE_ENV || e.charAt(0) === e.charAt(0).toLowerCase());
+}
+var G = "function" == typeof Symbol && Symbol.for;
+var Y = G ? Symbol.for("react.memo") : 60115;
+var q = G ? Symbol.for("react.forward_ref") : 60112;
+var W = { childContextTypes: true, contextType: true, contextTypes: true, defaultProps: true, displayName: true, getDefaultProps: true, getDerivedStateFromError: true, getDerivedStateFromProps: true, mixins: true, propTypes: true, type: true };
+var H = { name: true, length: true, prototype: true, caller: true, callee: true, arguments: true, arity: true };
+var U = { $$typeof: true, compare: true, defaultProps: true, displayName: true, propTypes: true, type: true };
+var J = ((V = {})[q] = { $$typeof: true, render: true, defaultProps: true, displayName: true, propTypes: true }, V[Y] = U, V);
+function X(e) {
+  return ("type" in (t = e) && t.type.$$typeof) === Y ? U : "$$typeof" in e ? J[e.$$typeof] : W;
+  var t;
+}
+var Z = Object.defineProperty;
+var K = Object.getOwnPropertyNames;
+var Q = Object.getOwnPropertySymbols;
+var ee = Object.getOwnPropertyDescriptor;
+var te = Object.getPrototypeOf;
+var ne = Object.prototype;
+function oe(e, t, n) {
+  if ("string" != typeof t) {
+    if (ne) {
+      var o2 = te(t);
+      o2 && o2 !== ne && oe(e, o2, n);
+    }
+    var r2 = K(t);
+    Q && (r2 = r2.concat(Q(t)));
+    for (var s2 = X(e), i2 = X(t), a3 = 0; a3 < r2.length; ++a3) {
+      var c2 = r2[a3];
+      if (!(c2 in H || n && n[c2] || i2 && c2 in i2 || s2 && c2 in s2)) {
+        var l2 = ee(t, c2);
+        try {
+          Z(e, c2, l2);
+        } catch (e2) {
+        }
+      }
+    }
+  }
+  return e;
+}
+function re(e) {
+  return "function" == typeof e;
+}
+function se(e) {
+  return "object" == typeof e && "styledComponentId" in e;
+}
+function ie(e, t) {
+  return e && t ? "".concat(e, " ").concat(t) : e || t || "";
+}
+function ae(e, t) {
+  if (0 === e.length) return "";
+  for (var n = e[0], o2 = 1; o2 < e.length; o2++) n += t ? t + e[o2] : e[o2];
+  return n;
+}
+function ce(e) {
+  return null !== e && "object" == typeof e && e.constructor.name === Object.name && !("props" in e && e.$$typeof);
+}
+function le(e, t, n) {
+  if (void 0 === n && (n = false), !n && !ce(e) && !Array.isArray(e)) return t;
+  if (Array.isArray(t)) for (var o2 = 0; o2 < t.length; o2++) e[o2] = le(e[o2], t[o2]);
+  else if (ce(t)) for (var o2 in t) e[o2] = le(e[o2], t[o2]);
+  return e;
+}
+function ue(e, t) {
+  Object.defineProperty(e, "toString", { value: t });
+}
+var pe = "production" !== process.env.NODE_ENV ? { 1: "Cannot create styled-component for component: %s.\n\n", 2: "Can't collect styles once you've consumed a `ServerStyleSheet`'s styles! `ServerStyleSheet` is a one off instance for each server-side render cycle.\n\n- Are you trying to reuse it across renders?\n- Are you accidentally calling collectStyles twice?\n\n", 3: "Streaming SSR is only supported in a Node.js environment; Please do not try to call this method in the browser.\n\n", 4: "The `StyleSheetManager` expects a valid target or sheet prop!\n\n- Does this error occur on the client and is your target falsy?\n- Does this error occur on the server and is the sheet falsy?\n\n", 5: "The clone method cannot be used on the client!\n\n- Are you running in a client-like environment on the server?\n- Are you trying to run SSR on the client?\n\n", 6: "Trying to insert a new style tag, but the given Node is unmounted!\n\n- Are you using a custom target that isn't mounted?\n- Does your document not have a valid head element?\n- Have you accidentally removed a style tag manually?\n\n", 7: 'ThemeProvider: Please return an object from your "theme" prop function, e.g.\n\n```js\ntheme={() => ({})}\n```\n\n', 8: 'ThemeProvider: Please make your "theme" prop an object.\n\n', 9: "Missing document `<head>`\n\n", 10: "Cannot find a StyleSheet instance. Usually this happens if there are multiple copies of styled-components loaded at once. Check out this issue for how to troubleshoot and fix the common cases where this situation can happen: https://github.com/styled-components/styled-components/issues/1941#issuecomment-417862021\n\n", 11: "_This error was replaced with a dev-time warning, it will be deleted for v4 final._ [createGlobalStyle] received children which will not be rendered. Please use the component without passing children elements.\n\n", 12: "It seems you are interpolating a keyframe declaration (%s) into an untagged string. This was supported in styled-components v3, but is not longer supported in v4 as keyframes are now injected on-demand. Please wrap your string in the css\\`\\` helper which ensures the styles are injected correctly. See https://www.styled-components.com/docs/api#css\n\n", 13: "%s is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.\n\n", 14: 'ThemeProvider: "theme" prop is required.\n\n', 15: "A stylis plugin has been supplied that is not named. We need a name for each plugin to be able to prevent styling collisions between different stylis configurations within the same app. Before you pass your plugin to `<StyleSheetManager stylisPlugins={[]}>`, please make sure each plugin is uniquely-named, e.g.\n\n```js\nObject.defineProperty(importedPlugin, 'name', { value: 'some-unique-name' });\n```\n\n", 16: "Reached the limit of how many styled components may be created at group %s.\nYou may only create up to 1,073,741,824 components. If you're creating components dynamically,\nas for instance in your render method then you may be running into this limitation.\n\n", 17: "CSSStyleSheet could not be found on HTMLStyleElement.\nHas styled-components' style tag been unmounted or altered by another script?\n", 18: "ThemeProvider: Please make sure your useTheme hook is within a `<ThemeProvider>`" } : {};
+function de() {
+  for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
+  for (var n = e[0], o2 = [], r2 = 1, s2 = e.length; r2 < s2; r2 += 1) o2.push(e[r2]);
+  return o2.forEach(function(e2) {
+    n = n.replace(/%[a-z]/, e2);
+  }), n;
+}
+function he(t) {
+  for (var n = [], o2 = 1; o2 < arguments.length; o2++) n[o2 - 1] = arguments[o2];
+  return "production" === process.env.NODE_ENV ? new Error("An error occurred. See https://github.com/styled-components/styled-components/blob/main/packages/styled-components/src/utils/errors.md#".concat(t, " for more information.").concat(n.length > 0 ? " Args: ".concat(n.join(", ")) : "")) : new Error(de.apply(void 0, __spreadArray([pe[t]], n, false)).trim());
+}
+var fe = function() {
+  function e(e2) {
+    this.groupSizes = new Uint32Array(512), this.length = 512, this.tag = e2;
+  }
+  return e.prototype.indexOfGroup = function(e2) {
+    for (var t = 0, n = 0; n < e2; n++) t += this.groupSizes[n];
+    return t;
+  }, e.prototype.insertRules = function(e2, t) {
+    if (e2 >= this.groupSizes.length) {
+      for (var n = this.groupSizes, o2 = n.length, r2 = o2; e2 >= r2; ) if ((r2 <<= 1) < 0) throw he(16, "".concat(e2));
+      this.groupSizes = new Uint32Array(r2), this.groupSizes.set(n), this.length = r2;
+      for (var s2 = o2; s2 < r2; s2++) this.groupSizes[s2] = 0;
+    }
+    for (var i2 = this.indexOfGroup(e2 + 1), a3 = (s2 = 0, t.length); s2 < a3; s2++) this.tag.insertRule(i2, t[s2]) && (this.groupSizes[e2]++, i2++);
+  }, e.prototype.clearGroup = function(e2) {
+    if (e2 < this.length) {
+      var t = this.groupSizes[e2], n = this.indexOfGroup(e2), o2 = n + t;
+      this.groupSizes[e2] = 0;
+      for (var r2 = n; r2 < o2; r2++) this.tag.deleteRule(n);
+    }
+  }, e.prototype.getGroup = function(e2) {
+    var t = "";
+    if (e2 >= this.length || 0 === this.groupSizes[e2]) return t;
+    for (var n = this.groupSizes[e2], o2 = this.indexOfGroup(e2), r2 = o2 + n, s2 = o2; s2 < r2; s2++) t += "".concat(this.tag.getRule(s2)).concat(g);
+    return t;
+  }, e;
+}();
+var me = 1 << 30;
+var ye = /* @__PURE__ */ new Map();
+var ve = /* @__PURE__ */ new Map();
+var ge = 1;
+var Se = function(e) {
+  if (ye.has(e)) return ye.get(e);
+  for (; ve.has(ge); ) ge++;
+  var t = ge++;
+  if ("production" !== process.env.NODE_ENV && ((0 | t) < 0 || t > me)) throw he(16, "".concat(t));
+  return ye.set(e, t), ve.set(t, e), t;
+};
+var we = function(e, t) {
+  ge = t + 1, ye.set(e, t), ve.set(t, e);
+};
+var be = "style[".concat(f, "][").concat(y, '="').concat(v, '"]');
+var Ee = new RegExp("^".concat(f, '\\.g(\\d+)\\[id="([\\w\\d-]+)"\\].*?"([^"]*)'));
+var Ne = function(e, t, n) {
+  for (var o2, r2 = n.split(","), s2 = 0, i2 = r2.length; s2 < i2; s2++) (o2 = r2[s2]) && e.registerName(t, o2);
+};
+var Pe = function(e, t) {
+  for (var n, o2 = (null !== (n = t.textContent) && void 0 !== n ? n : "").split(g), r2 = [], s2 = 0, i2 = o2.length; s2 < i2; s2++) {
+    var a3 = o2[s2].trim();
+    if (a3) {
+      var c2 = a3.match(Ee);
+      if (c2) {
+        var l2 = 0 | parseInt(c2[1], 10), u2 = c2[2];
+        0 !== l2 && (we(u2, l2), Ne(e, u2, c2[3]), e.getTag().insertRules(l2, r2)), r2.length = 0;
+      } else r2.push(a3);
+    }
+  }
+};
+function _e() {
+  return "undefined" != typeof __webpack_nonce__ ? __webpack_nonce__ : null;
+}
+var Ce = function(e) {
+  var t = document.head, n = e || t, o2 = document.createElement("style"), r2 = function(e2) {
+    var t2 = Array.from(e2.querySelectorAll("style[".concat(f, "]")));
+    return t2[t2.length - 1];
+  }(n), s2 = void 0 !== r2 ? r2.nextSibling : null;
+  o2.setAttribute(f, m), o2.setAttribute(y, v);
+  var i2 = _e();
+  return i2 && o2.setAttribute("nonce", i2), n.insertBefore(o2, s2), o2;
+};
+var Ie = function() {
+  function e(e2) {
+    this.element = Ce(e2), this.element.appendChild(document.createTextNode("")), this.sheet = function(e3) {
+      if (e3.sheet) return e3.sheet;
+      for (var t = document.styleSheets, n = 0, o2 = t.length; n < o2; n++) {
+        var r2 = t[n];
+        if (r2.ownerNode === e3) return r2;
+      }
+      throw he(17);
+    }(this.element), this.length = 0;
+  }
+  return e.prototype.insertRule = function(e2, t) {
+    try {
+      return this.sheet.insertRule(t, e2), this.length++, true;
+    } catch (e3) {
+      return false;
+    }
+  }, e.prototype.deleteRule = function(e2) {
+    this.sheet.deleteRule(e2), this.length--;
+  }, e.prototype.getRule = function(e2) {
+    var t = this.sheet.cssRules[e2];
+    return t && t.cssText ? t.cssText : "";
+  }, e;
+}();
+var Ae = function() {
+  function e(e2) {
+    this.element = Ce(e2), this.nodes = this.element.childNodes, this.length = 0;
+  }
+  return e.prototype.insertRule = function(e2, t) {
+    if (e2 <= this.length && e2 >= 0) {
+      var n = document.createTextNode(t);
+      return this.element.insertBefore(n, this.nodes[e2] || null), this.length++, true;
+    }
+    return false;
+  }, e.prototype.deleteRule = function(e2) {
+    this.element.removeChild(this.nodes[e2]), this.length--;
+  }, e.prototype.getRule = function(e2) {
+    return e2 < this.length ? this.nodes[e2].textContent : "";
+  }, e;
+}();
+var Oe = function() {
+  function e(e2) {
+    this.rules = [], this.length = 0;
+  }
+  return e.prototype.insertRule = function(e2, t) {
+    return e2 <= this.length && (this.rules.splice(e2, 0, t), this.length++, true);
+  }, e.prototype.deleteRule = function(e2) {
+    this.rules.splice(e2, 1), this.length--;
+  }, e.prototype.getRule = function(e2) {
+    return e2 < this.length ? this.rules[e2] : "";
+  }, e;
+}();
+var De = S;
+var Re = { isServer: !S, useCSSOMInjection: !w };
+var Te = function() {
+  function e(e2, n, o2) {
+    void 0 === e2 && (e2 = C), void 0 === n && (n = {});
+    var r2 = this;
+    this.options = __assign(__assign({}, Re), e2), this.gs = n, this.names = new Map(o2), this.server = !!e2.isServer, !this.server && S && De && (De = false, function(e3) {
+      for (var t = document.querySelectorAll(be), n2 = 0, o3 = t.length; n2 < o3; n2++) {
+        var r3 = t[n2];
+        r3 && r3.getAttribute(f) !== m && (Pe(e3, r3), r3.parentNode && r3.parentNode.removeChild(r3));
+      }
+    }(this)), ue(this, function() {
+      return function(e3) {
+        for (var t = e3.getTag(), n2 = t.length, o3 = "", r3 = function(n3) {
+          var r4 = function(e4) {
+            return ve.get(e4);
+          }(n3);
+          if (void 0 === r4) return "continue";
+          var s3 = e3.names.get(r4), i2 = t.getGroup(n3);
+          if (void 0 === s3 || 0 === i2.length) return "continue";
+          var a3 = "".concat(f, ".g").concat(n3, '[id="').concat(r4, '"]'), c2 = "";
+          void 0 !== s3 && s3.forEach(function(e4) {
+            e4.length > 0 && (c2 += "".concat(e4, ","));
+          }), o3 += "".concat(i2).concat(a3, '{content:"').concat(c2, '"}').concat(g);
+        }, s2 = 0; s2 < n2; s2++) r3(s2);
+        return o3;
+      }(r2);
+    });
+  }
+  return e.registerId = function(e2) {
+    return Se(e2);
+  }, e.prototype.reconstructWithOptions = function(n, o2) {
+    return void 0 === o2 && (o2 = true), new e(__assign(__assign({}, this.options), n), this.gs, o2 && this.names || void 0);
+  }, e.prototype.allocateGSInstance = function(e2) {
+    return this.gs[e2] = (this.gs[e2] || 0) + 1;
+  }, e.prototype.getTag = function() {
+    return this.tag || (this.tag = (e2 = function(e3) {
+      var t = e3.useCSSOMInjection, n = e3.target;
+      return e3.isServer ? new Oe(n) : t ? new Ie(n) : new Ae(n);
+    }(this.options), new fe(e2)));
+    var e2;
+  }, e.prototype.hasNameForId = function(e2, t) {
+    return this.names.has(e2) && this.names.get(e2).has(t);
+  }, e.prototype.registerName = function(e2, t) {
+    if (Se(e2), this.names.has(e2)) this.names.get(e2).add(t);
+    else {
+      var n = /* @__PURE__ */ new Set();
+      n.add(t), this.names.set(e2, n);
+    }
+  }, e.prototype.insertRules = function(e2, t, n) {
+    this.registerName(e2, t), this.getTag().insertRules(Se(e2), n);
+  }, e.prototype.clearNames = function(e2) {
+    this.names.has(e2) && this.names.get(e2).clear();
+  }, e.prototype.clearRules = function(e2) {
+    this.getTag().clearGroup(Se(e2)), this.clearNames(e2);
+  }, e.prototype.clearTag = function() {
+    this.tag = void 0;
+  }, e;
+}();
+var ke = /&/g;
+var je = /^\s*\/\/.*$/gm;
+function xe(e, t) {
+  return e.map(function(e2) {
+    return "rule" === e2.type && (e2.value = "".concat(t, " ").concat(e2.value), e2.value = e2.value.replaceAll(",", ",".concat(t, " ")), e2.props = e2.props.map(function(e3) {
+      return "".concat(t, " ").concat(e3);
+    })), Array.isArray(e2.children) && "@keyframes" !== e2.type && (e2.children = xe(e2.children, t)), e2;
+  });
+}
+function Ve(e) {
+  var t, n, o2, r2 = void 0 === e ? C : e, s2 = r2.options, i2 = void 0 === s2 ? C : s2, a3 = r2.plugins, c2 = void 0 === a3 ? _ : a3, l2 = function(e2, o3, r3) {
+    return r3.startsWith(n) && r3.endsWith(n) && r3.replaceAll(n, "").length > 0 ? ".".concat(t) : e2;
+  }, u2 = c2.slice();
+  u2.push(function(e2) {
+    e2.type === RULESET && e2.value.includes("&") && (e2.props[0] = e2.props[0].replace(ke, n).replace(o2, l2));
+  }), i2.prefix && u2.push(prefixer), u2.push(stringify);
+  var p2 = function(e2, r3, s3, a4) {
+    void 0 === r3 && (r3 = ""), void 0 === s3 && (s3 = ""), void 0 === a4 && (a4 = "&"), t = a4, n = r3, o2 = new RegExp("\\".concat(n, "\\b"), "g");
+    var c3 = e2.replace(je, ""), l3 = compile(s3 || r3 ? "".concat(s3, " ").concat(r3, " { ").concat(c3, " }") : c3);
+    i2.namespace && (l3 = xe(l3, i2.namespace));
+    var p3 = [];
+    return serialize(l3, middleware(u2.concat(rulesheet(function(e3) {
+      return p3.push(e3);
+    })))), p3;
+  };
+  return p2.hash = c2.length ? c2.reduce(function(e2, t2) {
+    return t2.name || he(15), M(e2, t2.name);
+  }, F).toString() : "", p2;
+}
+var Fe = new Te();
+var Me = Ve();
+var ze = import_react21.default.createContext({ shouldForwardProp: void 0, styleSheet: Fe, stylis: Me });
+var $e = ze.Consumer;
+var Be = import_react21.default.createContext(void 0);
+function Le() {
+  return (0, import_react21.useContext)(ze);
+}
+function Ge(e) {
+  var t = (0, import_react21.useState)(e.stylisPlugins), n = t[0], r2 = t[1], c2 = Le().styleSheet, l2 = (0, import_react21.useMemo)(function() {
+    var t2 = c2;
+    return e.sheet ? t2 = e.sheet : e.target && (t2 = t2.reconstructWithOptions({ target: e.target }, false)), e.disableCSSOMInjection && (t2 = t2.reconstructWithOptions({ useCSSOMInjection: false })), t2;
+  }, [e.disableCSSOMInjection, e.sheet, e.target, c2]), u2 = (0, import_react21.useMemo)(function() {
+    return Ve({ options: { namespace: e.namespace, prefix: e.enableVendorPrefixes }, plugins: n });
+  }, [e.enableVendorPrefixes, e.namespace, n]);
+  (0, import_react21.useEffect)(function() {
+    (0, import_shallowequal.default)(n, e.stylisPlugins) || r2(e.stylisPlugins);
+  }, [e.stylisPlugins]);
+  var d = (0, import_react21.useMemo)(function() {
+    return { shouldForwardProp: e.shouldForwardProp, styleSheet: l2, stylis: u2 };
+  }, [e.shouldForwardProp, l2, u2]);
+  return import_react21.default.createElement(ze.Provider, { value: d }, import_react21.default.createElement(Be.Provider, { value: u2 }, e.children));
+}
+var Ye = function() {
+  function e(e2, t) {
+    var n = this;
+    this.inject = function(e3, t2) {
+      void 0 === t2 && (t2 = Me);
+      var o2 = n.name + t2.hash;
+      e3.hasNameForId(n.id, o2) || e3.insertRules(n.id, o2, t2(n.rules, o2, "@keyframes"));
+    }, this.name = e2, this.id = "sc-keyframes-".concat(e2), this.rules = t, ue(this, function() {
+      throw he(12, String(n.name));
+    });
+  }
+  return e.prototype.getName = function(e2) {
+    return void 0 === e2 && (e2 = Me), this.name + e2.hash;
+  }, e;
+}();
+var qe = function(e) {
+  return e >= "A" && e <= "Z";
+};
+function We(e) {
+  for (var t = "", n = 0; n < e.length; n++) {
+    var o2 = e[n];
+    if (1 === n && "-" === o2 && "-" === e[0]) return e;
+    qe(o2) ? t += "-" + o2.toLowerCase() : t += o2;
+  }
+  return t.startsWith("ms-") ? "-" + t : t;
+}
+var He = function(e) {
+  return null == e || false === e || "" === e;
+};
+var Ue = function(t) {
+  var n, o2, r2 = [];
+  for (var s2 in t) {
+    var i2 = t[s2];
+    t.hasOwnProperty(s2) && !He(i2) && (Array.isArray(i2) && i2.isCss || re(i2) ? r2.push("".concat(We(s2), ":"), i2, ";") : ce(i2) ? r2.push.apply(r2, __spreadArray(__spreadArray(["".concat(s2, " {")], Ue(i2), false), ["}"], false)) : r2.push("".concat(We(s2), ": ").concat((n = s2, null == (o2 = i2) || "boolean" == typeof o2 || "" === o2 ? "" : "number" != typeof o2 || 0 === o2 || n in unitlessKeys || n.startsWith("--") ? String(o2).trim() : "".concat(o2, "px")), ";")));
+  }
+  return r2;
+};
+function Je(e, t, n, o2) {
+  if (He(e)) return [];
+  if (se(e)) return [".".concat(e.styledComponentId)];
+  if (re(e)) {
+    if (!re(s2 = e) || s2.prototype && s2.prototype.isReactComponent || !t) return [e];
+    var r2 = e(t);
+    return "production" === process.env.NODE_ENV || "object" != typeof r2 || Array.isArray(r2) || r2 instanceof Ye || ce(r2) || null === r2 || console.error("".concat(B(e), " is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.")), Je(r2, t, n, o2);
+  }
+  var s2;
+  return e instanceof Ye ? n ? (e.inject(n, o2), [e.getName(o2)]) : [e] : ce(e) ? Ue(e) : Array.isArray(e) ? Array.prototype.concat.apply(_, e.map(function(e2) {
+    return Je(e2, t, n, o2);
+  })) : [e.toString()];
+}
+function Xe(e) {
+  for (var t = 0; t < e.length; t += 1) {
+    var n = e[t];
+    if (re(n) && !se(n)) return false;
+  }
+  return true;
+}
+var Ze = z(v);
+var Ke = function() {
+  function e(e2, t, n) {
+    this.rules = e2, this.staticRulesId = "", this.isStatic = "production" === process.env.NODE_ENV && (void 0 === n || n.isStatic) && Xe(e2), this.componentId = t, this.baseHash = M(Ze, t), this.baseStyle = n, Te.registerId(t);
+  }
+  return e.prototype.generateAndInjectStyles = function(e2, t, n) {
+    var o2 = this.baseStyle ? this.baseStyle.generateAndInjectStyles(e2, t, n) : "";
+    if (this.isStatic && !n.hash) if (this.staticRulesId && t.hasNameForId(this.componentId, this.staticRulesId)) o2 = ie(o2, this.staticRulesId);
+    else {
+      var r2 = ae(Je(this.rules, e2, t, n)), s2 = x(M(this.baseHash, r2) >>> 0);
+      if (!t.hasNameForId(this.componentId, s2)) {
+        var i2 = n(r2, ".".concat(s2), void 0, this.componentId);
+        t.insertRules(this.componentId, s2, i2);
+      }
+      o2 = ie(o2, s2), this.staticRulesId = s2;
+    }
+    else {
+      for (var a3 = M(this.baseHash, n.hash), c2 = "", l2 = 0; l2 < this.rules.length; l2++) {
+        var u2 = this.rules[l2];
+        if ("string" == typeof u2) c2 += u2, "production" !== process.env.NODE_ENV && (a3 = M(a3, u2));
+        else if (u2) {
+          var p2 = ae(Je(u2, e2, t, n));
+          a3 = M(a3, p2 + l2), c2 += p2;
+        }
+      }
+      if (c2) {
+        var d = x(a3 >>> 0);
+        t.hasNameForId(this.componentId, d) || t.insertRules(this.componentId, d, n(c2, ".".concat(d), void 0, this.componentId)), o2 = ie(o2, d);
+      }
+    }
+    return o2;
+  }, e;
+}();
+var Qe = import_react21.default.createContext(void 0);
+var et = Qe.Consumer;
+var ot = {};
+var rt = /* @__PURE__ */ new Set();
+function st(e, r2, s2) {
+  var i2 = se(e), a3 = e, c2 = !L(e), p2 = r2.attrs, d = void 0 === p2 ? _ : p2, h = r2.componentId, f2 = void 0 === h ? function(e2, t) {
+    var n = "string" != typeof e2 ? "sc" : R(e2);
+    ot[n] = (ot[n] || 0) + 1;
+    var o2 = "".concat(n, "-").concat($(v + n + ot[n]));
+    return t ? "".concat(t, "-").concat(o2) : o2;
+  }(r2.displayName, r2.parentComponentId) : h, m2 = r2.displayName, y2 = void 0 === m2 ? function(e2) {
+    return L(e2) ? "styled.".concat(e2) : "Styled(".concat(B(e2), ")");
+  }(e) : m2, g2 = r2.displayName && r2.componentId ? "".concat(R(r2.displayName), "-").concat(r2.componentId) : r2.componentId || f2, S2 = i2 && a3.attrs ? a3.attrs.concat(d).filter(Boolean) : d, w2 = r2.shouldForwardProp;
+  if (i2 && a3.shouldForwardProp) {
+    var b = a3.shouldForwardProp;
+    if (r2.shouldForwardProp) {
+      var E2 = r2.shouldForwardProp;
+      w2 = function(e2, t) {
+        return b(e2, t) && E2(e2, t);
+      };
+    } else w2 = b;
+  }
+  var N2 = new Ke(s2, g2, i2 ? a3.componentStyle : void 0);
+  function O2(e2, r3) {
+    return function(e3, r4, s3) {
+      var i3 = e3.attrs, a4 = e3.componentStyle, c3 = e3.defaultProps, p3 = e3.foldedComponentIds, d2 = e3.styledComponentId, h2 = e3.target, f3 = import_react21.default.useContext(Qe), m3 = Le(), y3 = e3.shouldForwardProp || m3.shouldForwardProp;
+      "production" !== process.env.NODE_ENV && (0, import_react21.useDebugValue)(d2);
+      var v2 = I(r4, f3, c3) || C, g3 = function(e4, n, o2) {
+        for (var r5, s4 = __assign(__assign({}, n), { className: void 0, theme: o2 }), i4 = 0; i4 < e4.length; i4 += 1) {
+          var a5 = re(r5 = e4[i4]) ? r5(s4) : r5;
+          for (var c4 in a5) s4[c4] = "className" === c4 ? ie(s4[c4], a5[c4]) : "style" === c4 ? __assign(__assign({}, s4[c4]), a5[c4]) : a5[c4];
+        }
+        return n.className && (s4.className = ie(s4.className, n.className)), s4;
+      }(i3, r4, v2), S3 = g3.as || h2, w3 = {};
+      for (var b2 in g3) void 0 === g3[b2] || "$" === b2[0] || "as" === b2 || "theme" === b2 && g3.theme === v2 || ("forwardedAs" === b2 ? w3.as = g3.forwardedAs : y3 && !y3(b2, S3) || (w3[b2] = g3[b2], y3 || "development" !== process.env.NODE_ENV || isPropValid(b2) || rt.has(b2) || !A.has(S3) || (rt.add(b2), console.warn('styled-components: it looks like an unknown prop "'.concat(b2, '" is being sent through to the DOM, which will likely trigger a React console error. If you would like automatic filtering of unknown props, you can opt-into that behavior via `<StyleSheetManager shouldForwardProp={...}>` (connect an API like `@emotion/is-prop-valid`) or consider using transient props (`$` prefix for automatic filtering.)')))));
+      var E3 = function(e4, t) {
+        var n = Le(), o2 = e4.generateAndInjectStyles(t, n.styleSheet, n.stylis);
+        return "production" !== process.env.NODE_ENV && (0, import_react21.useDebugValue)(o2), o2;
+      }(a4, g3);
+      "production" !== process.env.NODE_ENV && e3.warnTooManyClasses && e3.warnTooManyClasses(E3);
+      var N3 = ie(p3, d2);
+      return E3 && (N3 += " " + E3), g3.className && (N3 += " " + g3.className), w3[L(S3) && !A.has(S3) ? "class" : "className"] = N3, w3.ref = s3, (0, import_react21.createElement)(S3, w3);
+    }(D2, e2, r3);
+  }
+  O2.displayName = y2;
+  var D2 = import_react21.default.forwardRef(O2);
+  return D2.attrs = S2, D2.componentStyle = N2, D2.displayName = y2, D2.shouldForwardProp = w2, D2.foldedComponentIds = i2 ? ie(a3.foldedComponentIds, a3.styledComponentId) : "", D2.styledComponentId = g2, D2.target = i2 ? a3.target : e, Object.defineProperty(D2, "defaultProps", { get: function() {
+    return this._foldedDefaultProps;
+  }, set: function(e2) {
+    this._foldedDefaultProps = i2 ? function(e3) {
+      for (var t = [], n = 1; n < arguments.length; n++) t[n - 1] = arguments[n];
+      for (var o2 = 0, r3 = t; o2 < r3.length; o2++) le(e3, r3[o2], true);
+      return e3;
+    }({}, a3.defaultProps, e2) : e2;
+  } }), "production" !== process.env.NODE_ENV && (P(y2, g2), D2.warnTooManyClasses = /* @__PURE__ */ function(e2, t) {
+    var n = {}, o2 = false;
+    return function(r3) {
+      if (!o2 && (n[r3] = true, Object.keys(n).length >= 200)) {
+        var s3 = t ? ' with the id of "'.concat(t, '"') : "";
+        console.warn("Over ".concat(200, " classes were generated for component ").concat(e2).concat(s3, ".\n") + "Consider using the attrs method, together with a style object for frequently changed styles.\nExample:\n  const Component = styled.div.attrs(props => ({\n    style: {\n      background: props.background,\n    },\n  }))`width: 100%;`\n\n  <Component />"), o2 = true, n = {};
+      }
+    };
+  }(y2, g2)), ue(D2, function() {
+    return ".".concat(D2.styledComponentId);
+  }), c2 && oe(D2, e, { attrs: true, componentStyle: true, displayName: true, foldedComponentIds: true, shouldForwardProp: true, styledComponentId: true, target: true }), D2;
+}
+function it(e, t) {
+  for (var n = [e[0]], o2 = 0, r2 = t.length; o2 < r2; o2 += 1) n.push(t[o2], e[o2 + 1]);
+  return n;
+}
+var at = function(e) {
+  return Object.assign(e, { isCss: true });
+};
+function ct(t) {
+  for (var n = [], o2 = 1; o2 < arguments.length; o2++) n[o2 - 1] = arguments[o2];
+  if (re(t) || ce(t)) return at(Je(it(_, __spreadArray([t], n, true))));
+  var r2 = t;
+  return 0 === n.length && 1 === r2.length && "string" == typeof r2[0] ? Je(r2) : at(Je(it(r2, n)));
+}
+function lt(n, o2, r2) {
+  if (void 0 === r2 && (r2 = C), !o2) throw he(1, o2);
+  var s2 = function(t) {
+    for (var s3 = [], i2 = 1; i2 < arguments.length; i2++) s3[i2 - 1] = arguments[i2];
+    return n(o2, r2, ct.apply(void 0, __spreadArray([t], s3, false)));
+  };
+  return s2.attrs = function(e) {
+    return lt(n, o2, __assign(__assign({}, r2), { attrs: Array.prototype.concat(r2.attrs, e).filter(Boolean) }));
+  }, s2.withConfig = function(e) {
+    return lt(n, o2, __assign(__assign({}, r2), e));
+  }, s2;
+}
+var ut = function(e) {
+  return lt(st, e);
+};
+var pt = ut;
+A.forEach(function(e) {
+  pt[e] = ut(e);
+});
+var dt = function() {
+  function e(e2, t) {
+    this.rules = e2, this.componentId = t, this.isStatic = Xe(e2), Te.registerId(this.componentId + 1);
+  }
+  return e.prototype.createStyles = function(e2, t, n, o2) {
+    var r2 = o2(ae(Je(this.rules, t, n, o2)), ""), s2 = this.componentId + e2;
+    n.insertRules(s2, s2, r2);
+  }, e.prototype.removeStyles = function(e2, t) {
+    t.clearRules(this.componentId + e2);
+  }, e.prototype.renderStyles = function(e2, t, n, o2) {
+    e2 > 2 && Te.registerId(this.componentId + e2), this.removeStyles(e2, n), this.createStyles(e2, t, n, o2);
+  }, e;
+}();
+var yt = /^\s*<\/[a-z]/i;
+var vt = function() {
+  function e() {
+    var e2 = this;
+    this._emitSheetCSS = function() {
+      var t = e2.instance.toString(), n = _e(), o2 = ae([n && 'nonce="'.concat(n, '"'), "".concat(f, '="true"'), "".concat(y, '="').concat(v, '"')].filter(Boolean), " ");
+      return "<style ".concat(o2, ">").concat(t, "</style>");
+    }, this.getStyleTags = function() {
+      if (e2.sealed) throw he(2);
+      return e2._emitSheetCSS();
+    }, this.getStyleElement = function() {
+      var n;
+      if (e2.sealed) throw he(2);
+      var r2 = ((n = {})[f] = "", n[y] = v, n.dangerouslySetInnerHTML = { __html: e2.instance.toString() }, n), s2 = _e();
+      return s2 && (r2.nonce = s2), [import_react21.default.createElement("style", __assign({}, r2, { key: "sc-0-0" }))];
+    }, this.seal = function() {
+      e2.sealed = true;
+    }, this.instance = new Te({ isServer: true }), this.sealed = false;
+  }
+  return e.prototype.collectStyles = function(e2) {
+    if (this.sealed) throw he(2);
+    return import_react21.default.createElement(Ge, { sheet: this.instance }, e2);
+  }, e.prototype.interleaveWithNodeStream = function(e2) {
+    if (S) throw he(3);
+    if (this.sealed) throw he(2);
+    this.seal();
+    var t = require("stream").Transform, n = e2, o2 = this.instance, r2 = this._emitSheetCSS, s2 = new t({ transform: function(e3, t2, n2) {
+      var s3 = e3.toString(), i2 = r2();
+      if (o2.clearTag(), yt.test(s3)) {
+        var a3 = s3.indexOf(">") + 1, c2 = s3.slice(0, a3), l2 = s3.slice(a3);
+        this.push(c2 + i2 + l2);
+      } else this.push(i2 + s3);
+      n2();
+    } });
+    return n.on("error", function(e3) {
+      s2.emit("error", e3);
+    }), n.pipe(s2);
+  }, e;
+}();
+"production" !== process.env.NODE_ENV && "undefined" != typeof navigator && "ReactNative" === navigator.product && console.warn("It looks like you've imported 'styled-components' on React Native.\nPerhaps you're looking to import 'styled-components/native'?\nRead more about this at https://www.styled-components.com/docs/basics#react-native");
+var St = "__sc-".concat(f, "__");
+"production" !== process.env.NODE_ENV && "test" !== process.env.NODE_ENV && "undefined" != typeof window && (window[St] || (window[St] = 0), 1 === window[St] && console.warn("It looks like there are several instances of 'styled-components' initialized in this application. This may cause dynamic styles to not render properly, errors during the rehydration process, a missing theme prop, and makes your application bigger without good reason.\n\nSee https://s-c.sh/2BAXzed for more info."), window[St] += 1);
+
 // src/components/helpers/styling/visibilityTransition.tsx
-var import_styled_components = require("styled-components");
 var visibilityTransition = (open) => {
-  return import_styled_components.css`
+  return ct`
     @media (prefers-reduced-motion: no-preference) {
       transition:
         visibility 0.4s,
@@ -3142,7 +4435,7 @@ var visibilityTransition = (open) => {
 };
 
 // src/components/BackLink/BackLink.tsx
-var import_react21 = require("react");
+var import_react22 = require("react");
 
 // src/components/BackLink/BackLink.module.css
 var BackLink_default = {
@@ -3151,7 +4444,7 @@ var BackLink_default = {
 
 // src/components/BackLink/BackLink.tsx
 var import_jsx_runtime174 = require("react/jsx-runtime");
-var BackLink = (0, import_react21.forwardRef)((props, ref) => {
+var BackLink = (0, import_react22.forwardRef)((props, ref) => {
   return /* @__PURE__ */ (0, import_jsx_runtime174.jsx)("nav", { ref, "aria-label": "g\xE5 tilbake", children: /* @__PURE__ */ (0, import_jsx_runtime174.jsxs)(Link, { href: props.href, className: BackLink_default.link, children: [
     /* @__PURE__ */ (0, import_jsx_runtime174.jsx)(Icon, { icon: ArrowLeftIcon, iconSize: "small" }),
     props.label
@@ -3160,12 +4453,12 @@ var BackLink = (0, import_react21.forwardRef)((props, ref) => {
 BackLink.displayName = "BackLink";
 
 // src/components/Breadcrumbs/Breadcrumb.tsx
-var import_react22 = require("react");
+var import_react23 = require("react");
 var import_jsx_runtime175 = require("react/jsx-runtime");
 var isAnchorTypographyProps = (props) => {
   return props.href != void 0;
 };
-var Breadcrumb = (0, import_react22.forwardRef)(
+var Breadcrumb = (0, import_react23.forwardRef)(
   (props, ref) => {
     const { children, ...rest } = props;
     if (isAnchorTypographyProps(props)) {
@@ -3177,7 +4470,7 @@ var Breadcrumb = (0, import_react22.forwardRef)(
 Breadcrumb.displayName = "Breadcrumb";
 
 // src/components/Breadcrumbs/Breadcrumbs.tsx
-var import_react29 = require("react");
+var import_react30 = require("react");
 
 // src/components/Breadcrumbs/Breadcrumbs.module.css
 var Breadcrumbs_default = {
@@ -3189,7 +4482,7 @@ var Breadcrumbs_default = {
 
 // src/components/Button/Button.tsx
 var import_dds_design_tokens12 = require("@norges-domstoler/dds-design-tokens");
-var import_react24 = require("react");
+var import_react25 = require("react");
 
 // src/components/Button/Button.module.css
 var Button_default = {
@@ -3261,7 +4554,7 @@ var buttonTokens = {
 };
 
 // src/components/Spinner/Spinner.tsx
-var import_react23 = require("react");
+var import_react24 = require("react");
 
 // src/components/Spinner/Spinner.module.css
 var Spinner_default = {
@@ -3283,10 +4576,10 @@ function Spinner(props) {
     htmlProps,
     ...rest
   } = props;
-  const mountTime = (0, import_react23.useRef)(Date.now());
+  const mountTime = (0, import_react24.useRef)(Date.now());
   const outerAnimationDelay = -(mountTime.current % 2e3);
   const innerAnimationDelay = -(mountTime.current % 1500);
-  const generatedId = (0, import_react23.useId)();
+  const generatedId = (0, import_react24.useId)();
   const uniqueId = `${generatedId}-spinnerTitle`;
   return /* @__PURE__ */ (0, import_jsx_runtime176.jsxs)(
     "svg",
@@ -3333,7 +4626,7 @@ var typographyTypes = {
   tiny: "supportingStyleTiny01"
 };
 var { button: button2 } = buttonTokens;
-var Button = (0, import_react24.forwardRef)(
+var Button = (0, import_react25.forwardRef)(
   (props, ref) => {
     const {
       children,
@@ -3448,7 +4741,7 @@ Button.displayName = "Button";
 
 // src/components/OverflowMenu/OverflowMenu.tsx
 var import_dds_design_tokens13 = require("@norges-domstoler/dds-design-tokens");
-var import_react27 = require("react");
+var import_react28 = require("react");
 
 // src/components/OverflowMenu/OverflowMenu.module.css
 var OverflowMenu_default = {
@@ -3461,11 +4754,11 @@ var OverflowMenu_default = {
 };
 
 // src/components/OverflowMenu/OverflowMenuItem.tsx
-var import_react25 = require("react");
+var import_react26 = require("react");
 var import_jsx_runtime178 = require("react/jsx-runtime");
 var isAnchorProps2 = (props) => props.href !== void 0;
 var isButtonProps = (props) => props.href === void 0 && props.onClick !== void 0;
-var OverflowMenuItem = (0, import_react25.forwardRef)((props, ref) => {
+var OverflowMenuItem = (0, import_react26.forwardRef)((props, ref) => {
   const { title, icon: icon2, focus, id, className, htmlProps = {}, ...rest } = props;
   let href;
   let onClick;
@@ -3474,9 +4767,9 @@ var OverflowMenuItem = (0, import_react25.forwardRef)((props, ref) => {
   } else if (isButtonProps(props)) {
     onClick = props.onClick;
   }
-  const itemRef = (0, import_react25.useRef)(null);
+  const itemRef = (0, import_react26.useRef)(null);
   const combinedRef = useCombinedRef(ref, itemRef);
-  (0, import_react25.useEffect)(() => {
+  (0, import_react26.useEffect)(() => {
     var _a;
     if (focus) {
       (_a = itemRef.current) == null ? void 0 : _a.focus();
@@ -3541,7 +4834,7 @@ var OverflowMenuItem = (0, import_react25.forwardRef)((props, ref) => {
 OverflowMenuItem.displayName = "OverflowMenuItem";
 
 // src/components/Divider/Divider.tsx
-var import_react26 = require("react");
+var import_react27 = require("react");
 
 // src/components/Divider/Divider.module.css
 var Divider_default = {
@@ -3553,7 +4846,7 @@ var Divider_default = {
 
 // src/components/Divider/Divider.tsx
 var import_jsx_runtime179 = require("react/jsx-runtime");
-var Divider = (0, import_react26.forwardRef)((props, ref) => {
+var Divider = (0, import_react27.forwardRef)((props, ref) => {
   const { color = "default", id, className, htmlProps, ...rest } = props;
   const colorCn = color === "default" || color === "subtle" ? color : "on-inverse";
   const lineProps = {
@@ -3571,7 +4864,7 @@ Divider.displayName = "Divider";
 
 // src/components/OverflowMenu/OverflowMenu.tsx
 var import_jsx_runtime180 = require("react/jsx-runtime");
-var OverflowMenu = (0, import_react27.forwardRef)(
+var OverflowMenu = (0, import_react28.forwardRef)(
   (props, ref) => {
     var _a, _b;
     const {
@@ -3594,7 +4887,7 @@ var OverflowMenu = (0, import_react27.forwardRef)(
       offset
     });
     const combinedRef = useCombinedRef(ref, refs.setFloating);
-    (0, import_react27.useEffect)(() => {
+    (0, import_react28.useEffect)(() => {
       anchorRef ? refs.setReference(anchorRef.current) : refs.setReference(null);
     }, [anchorRef]);
     useOnClickOutside(
@@ -3667,7 +4960,7 @@ var OverflowMenu = (0, import_react27.forwardRef)(
       }
     };
     const { style = {}, ...restHTMLProps } = htmlProps;
-    const generatedId = (0, import_react27.useId)();
+    const generatedId = (0, import_react28.useId)();
     return /* @__PURE__ */ (0, import_jsx_runtime180.jsxs)(
       Paper,
       {
@@ -3699,7 +4992,7 @@ var OverflowMenu = (0, import_react27.forwardRef)(
 OverflowMenu.displayName = "OverflowMenu";
 
 // src/components/OverflowMenu/OverflowMenuGroup.tsx
-var import_react28 = require("react");
+var import_react29 = require("react");
 var import_jsx_runtime181 = require("react/jsx-runtime");
 var OverflowMenuGroup = ({
   children,
@@ -3708,11 +5001,11 @@ var OverflowMenuGroup = ({
   onOpen,
   overflowMenuId
 }) => {
-  const [isOpen, setIsOpen] = (0, import_react28.useState)(false);
+  const [isOpen, setIsOpen] = (0, import_react29.useState)(false);
   const toggle = () => setIsOpen(!isOpen);
   const close = () => setIsOpen(false);
-  const buttonRef = (0, import_react28.useRef)(null);
-  const generatedId = (0, import_react28.useId)();
+  const buttonRef = (0, import_react29.useRef)(null);
+  const generatedId = (0, import_react29.useId)();
   const uniqueOverflowMenuId = overflowMenuId != null ? overflowMenuId : `${generatedId}-overflowMenu`;
   const handleClose = () => {
     onClose && onClose();
@@ -3724,14 +5017,14 @@ var OverflowMenuGroup = ({
     onToggle && onToggle();
     toggle();
   };
-  const Children8 = import_react28.Children.map(children, (child, childIndex) => {
-    return (0, import_react28.isValidElement)(child) && (childIndex === 0 ? (0, import_react28.cloneElement)(child, {
+  const Children8 = import_react29.Children.map(children, (child, childIndex) => {
+    return (0, import_react29.isValidElement)(child) && (childIndex === 0 ? (0, import_react29.cloneElement)(child, {
       "aria-haspopup": "menu",
       "aria-controls": uniqueOverflowMenuId,
       "aria-expanded": isOpen,
       onClick: handleToggle,
       ref: buttonRef
-    }) : (0, import_react28.cloneElement)(child, {
+    }) : (0, import_react29.cloneElement)(child, {
       isOpen,
       id: uniqueOverflowMenuId,
       onClose: handleClose,
@@ -3745,7 +5038,7 @@ OverflowMenuGroup.displayName = "OverflowMenuGroup";
 
 // src/components/Breadcrumbs/Breadcrumbs.tsx
 var import_jsx_runtime182 = require("react/jsx-runtime");
-var Breadcrumbs = (0, import_react29.forwardRef)(
+var Breadcrumbs = (0, import_react30.forwardRef)(
   (props, ref) => {
     const { children, smallScreen, id, className, htmlProps, ...rest } = props;
     const chevronIcon = /* @__PURE__ */ (0, import_jsx_runtime182.jsx)(
@@ -3756,7 +5049,7 @@ var Breadcrumbs = (0, import_react29.forwardRef)(
         icon: ChevronRightIcon
       }
     );
-    const childrenArray = import_react29.Children.toArray(children);
+    const childrenArray = import_react30.Children.toArray(children);
     const listItemCn = cn(
       Breadcrumbs_default["list-item"],
       !smallScreen && Breadcrumbs_default[`list-item--large-screen`]
@@ -3768,7 +5061,7 @@ var Breadcrumbs = (0, import_react29.forwardRef)(
       ] }, `breadcrumb-${index}`);
     });
     const breadcrumbChildrenTruncated = childrenArray.length > 2 ? childrenArray.slice(1, childrenArray.length - 1).map((item) => {
-      if ((0, import_react29.isValidElement)(item))
+      if ((0, import_react30.isValidElement)(item))
         return {
           title: item.props.children,
           href: item.props.href
@@ -3810,7 +5103,7 @@ var Breadcrumbs = (0, import_react29.forwardRef)(
 Breadcrumbs.displayName = "Breadcrumbs";
 
 // src/components/ButtonGroup/ButtonGroup.tsx
-var import_react30 = require("react");
+var import_react31 = require("react");
 
 // src/components/ButtonGroup/ButtonGroup.module.css
 var ButtonGroup_default = {
@@ -3821,7 +5114,7 @@ var ButtonGroup_default = {
 
 // src/components/ButtonGroup/ButtonGroup.tsx
 var import_jsx_runtime183 = require("react/jsx-runtime");
-var ButtonGroup = (0, import_react30.forwardRef)(
+var ButtonGroup = (0, import_react31.forwardRef)(
   (props, ref) => {
     const {
       children,
@@ -3833,8 +5126,8 @@ var ButtonGroup = (0, import_react30.forwardRef)(
       role = "group",
       ...rest
     } = props;
-    const Children8 = import_react30.Children.map(children, (child) => {
-      return (0, import_react30.isValidElement)(child) && (0, import_react30.cloneElement)(child, {
+    const Children8 = import_react31.Children.map(children, (child) => {
+      return (0, import_react31.isValidElement)(child) && (0, import_react31.cloneElement)(child, {
         purpose: "secondary",
         size: buttonSize
       });
@@ -3907,12 +5200,12 @@ var Card = (props) => {
 Card.displayName = "Card";
 
 // src/components/Card/CardAccordion/CardAccordion.tsx
-var import_react32 = require("react");
+var import_react33 = require("react");
 
 // src/components/Card/CardAccordion/CardAccordionContext.tsx
-var import_react31 = require("react");
+var import_react32 = require("react");
 var import_jsx_runtime185 = require("react/jsx-runtime");
-var CardAccordionContext = (0, import_react31.createContext)({});
+var CardAccordionContext = (0, import_react32.createContext)({});
 var CardAccordionContextProvider = ({
   children,
   ...values
@@ -3920,7 +5213,7 @@ var CardAccordionContextProvider = ({
   return /* @__PURE__ */ (0, import_jsx_runtime185.jsx)(CardAccordionContext.Provider, { value: values, children });
 };
 var useCardAccordionContext = () => {
-  const context = (0, import_react31.useContext)(CardAccordionContext);
+  const context = (0, import_react32.useContext)(CardAccordionContext);
   if (!context) {
     throw new Error(
       "useCardAccordionContext must be used within a CardAccordionContextProvider. Have you wrapped <CardAccordionHeader> and <CardAccordionBody> inside a <CardAccordion>?"
@@ -3931,7 +5224,7 @@ var useCardAccordionContext = () => {
 
 // src/components/Card/CardAccordion/CardAccordion.tsx
 var import_jsx_runtime186 = require("react/jsx-runtime");
-var CardAccordion = (0, import_react32.forwardRef)(
+var CardAccordion = (0, import_react33.forwardRef)(
   (props, ref) => {
     const {
       isExpanded = false,
@@ -3942,13 +5235,13 @@ var CardAccordion = (0, import_react32.forwardRef)(
       htmlProps,
       ...rest
     } = props;
-    const [expanded, setExpanded] = (0, import_react32.useState)(isExpanded);
-    const generatedId = (0, import_react32.useId)();
+    const [expanded, setExpanded] = (0, import_react33.useState)(isExpanded);
+    const generatedId = (0, import_react33.useId)();
     const accordionId = id != null ? id : `${generatedId}-cardAccordion`;
-    (0, import_react32.useEffect)(() => {
+    (0, import_react33.useEffect)(() => {
       setExpanded(isExpanded);
     }, [isExpanded]);
-    const toggleExpanded = (0, import_react32.useCallback)(() => {
+    const toggleExpanded = (0, import_react33.useCallback)(() => {
       setExpanded((prevExpanded) => {
         const newExpanded = !prevExpanded;
         if (onChange) {
@@ -3973,7 +5266,7 @@ CardAccordion.displayName = "CardAccordion";
 
 // src/components/Card/CardAccordion/CardAccordionHeader.tsx
 var import_dds_design_tokens14 = require("@norges-domstoler/dds-design-tokens");
-var import_react33 = require("react");
+var import_react34 = require("react");
 
 // src/components/Card/CardAccordion/CardAccordion.module.css
 var CardAccordion_default = {
@@ -3989,7 +5282,7 @@ var CardAccordion_default = {
 
 // src/components/Card/CardAccordion/CardAccordionHeader.tsx
 var import_jsx_runtime187 = require("react/jsx-runtime");
-var CardAccordionHeader = (0, import_react33.forwardRef)((props, ref) => {
+var CardAccordionHeader = (0, import_react34.forwardRef)((props, ref) => {
   const {
     children,
     className,
@@ -4057,13 +5350,13 @@ var CardAccordionHeader = (0, import_react33.forwardRef)((props, ref) => {
 CardAccordionHeader.displayName = "CardAccordionHeader";
 
 // src/components/Card/CardAccordion/CardAccordionBody.tsx
-var import_react35 = require("react");
+var import_react36 = require("react");
 
 // src/components/Card/CardAccordion/useElementHeight.ts
-var import_react34 = require("react");
+var import_react35 = require("react");
 function useElementHeight(element) {
-  const [height, setHeight] = (0, import_react34.useState)(null);
-  (0, import_react34.useEffect)(() => {
+  const [height, setHeight] = (0, import_react35.useState)(null);
+  (0, import_react35.useEffect)(() => {
     if (!element) return;
     const resizeObserver = new ResizeObserver(() => {
       setHeight(element.offsetHeight);
@@ -4076,21 +5369,21 @@ function useElementHeight(element) {
 
 // src/components/Card/CardAccordion/CardAccordionBody.tsx
 var import_jsx_runtime188 = require("react/jsx-runtime");
-var CardAccordionBody = (0, import_react35.forwardRef)((props, ref) => {
+var CardAccordionBody = (0, import_react36.forwardRef)((props, ref) => {
   var _a;
   const { children, className, htmlProps, padding, ...rest } = props;
   const { headerId, isExpanded, bodyId: id } = useCardAccordionContext();
-  const bodyRef = (0, import_react35.useRef)(null);
-  const [animate, setAnimate] = (0, import_react35.useState)(false);
+  const bodyRef = (0, import_react36.useRef)(null);
+  const [animate, setAnimate] = (0, import_react36.useState)(false);
   const isMounted = useIsMounted();
   const height = useElementHeight(bodyRef.current);
-  const [initialExpandedHeight, setIntialExpandedHeight] = (0, import_react35.useState)(null);
-  (0, import_react35.useLayoutEffect)(() => {
+  const [initialExpandedHeight, setIntialExpandedHeight] = (0, import_react36.useState)(null);
+  (0, import_react36.useLayoutEffect)(() => {
     if (bodyRef.current && isExpanded) {
       setIntialExpandedHeight(bodyRef.current.scrollHeight);
     }
   }, []);
-  (0, import_react35.useEffect)(() => {
+  (0, import_react36.useEffect)(() => {
     if (isMounted()) {
       setAnimate(true);
     }
@@ -4138,7 +5431,7 @@ var CardAccordionBody = (0, import_react35.forwardRef)((props, ref) => {
 CardAccordionBody.displayName = "CardAccordionBody";
 
 // src/components/Chip/Chip.tsx
-var import_react36 = require("react");
+var import_react37 = require("react");
 
 // src/components/Chip/Chip.module.css
 var Chip_default = {
@@ -4148,10 +5441,10 @@ var Chip_default = {
 
 // src/components/Chip/Chip.tsx
 var import_jsx_runtime189 = require("react/jsx-runtime");
-var Chip = (0, import_react36.forwardRef)((props, ref) => {
+var Chip = (0, import_react37.forwardRef)((props, ref) => {
   const { text, onClose, id, className, htmlProps = {}, ...rest } = props;
   const { "aria-label": ariaLabel, ...restHTMLprops } = htmlProps;
-  const [isOpen, setIsOpen] = (0, import_react36.useState)(true);
+  const [isOpen, setIsOpen] = (0, import_react37.useState)(true);
   const onClick = () => {
     setIsOpen(false);
     onClose && onClose();
@@ -4191,11 +5484,11 @@ var Chip = (0, import_react36.forwardRef)((props, ref) => {
 Chip.displayName = "Chip";
 
 // src/components/Chip/ChipGroup.tsx
-var import_react37 = require("react");
+var import_react38 = require("react");
 var import_jsx_runtime190 = require("react/jsx-runtime");
-var ChipGroup = (0, import_react37.forwardRef)(
+var ChipGroup = (0, import_react38.forwardRef)(
   ({ children, className, ...rest }, ref) => {
-    const childrenArray = import_react37.Children.toArray(children);
+    const childrenArray = import_react38.Children.toArray(children);
     return /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(
       "ul",
       {
@@ -4218,7 +5511,7 @@ var import_date4 = require("@internationalized/date");
 var import_calendar3 = require("@react-aria/calendar");
 var import_i18n2 = require("@react-aria/i18n");
 var import_calendar4 = require("@react-stately/calendar");
-var import_react40 = require("react");
+var import_react41 = require("react");
 
 // src/components/date-inputs/DatePicker/Calendar/CalendarGrid.tsx
 var import_date3 = require("@internationalized/date");
@@ -4228,7 +5521,7 @@ var import_i18n = require("@react-aria/i18n");
 // src/components/date-inputs/DatePicker/Calendar/CalendarCell.tsx
 var import_date = require("@internationalized/date");
 var import_calendar = require("@react-aria/calendar");
-var import_react39 = require("react");
+var import_react40 = require("react");
 
 // src/components/date-inputs/common/DateInput.module.css
 var DateInput_default = {
@@ -4263,9 +5556,9 @@ var DateInput_default = {
 };
 
 // src/components/date-inputs/DatePicker/CalendarPopover.tsx
-var import_react38 = require("react");
+var import_react39 = require("react");
 var import_jsx_runtime191 = require("react/jsx-runtime");
-var CalendarPopoverContext = (0, import_react38.createContext)({
+var CalendarPopoverContext = (0, import_react39.createContext)({
   anchorRef: null,
   isOpen: false,
   onClose: () => null
@@ -4275,27 +5568,27 @@ var CalendarPopover = ({
   isOpen,
   onClose
 }) => {
-  const anchorRef = (0, import_react38.useRef)(null);
+  const anchorRef = (0, import_react39.useRef)(null);
   useOnKeyDown("Escape", onClose);
   return /* @__PURE__ */ (0, import_jsx_runtime191.jsx)(CalendarPopoverContext.Provider, { value: { anchorRef, isOpen, onClose }, children });
 };
 var CalendarPopoverAnchor = ({
   children
 }) => {
-  const { anchorRef } = (0, import_react38.useContext)(CalendarPopoverContext);
+  const { anchorRef } = (0, import_react39.useContext)(CalendarPopoverContext);
   return /* @__PURE__ */ (0, import_jsx_runtime191.jsx)("div", { ref: anchorRef != null ? anchorRef : void 0, children });
 };
 var CalendarPopoverContent = ({
   children
 }) => {
-  const ref = (0, import_react38.useRef)(null);
+  const ref = (0, import_react39.useRef)(null);
   const { refs, styles: floatingStyles } = useFloatPosition(null, {
     placement: "bottom-start"
   });
-  const { isOpen, onClose, anchorRef } = (0, import_react38.useContext)(CalendarPopoverContext);
+  const { isOpen, onClose, anchorRef } = (0, import_react39.useContext)(CalendarPopoverContext);
   const combinedRef = useCombinedRef(refs.setFloating, ref);
   useOnClickOutside(ref.current, onClose);
-  (0, import_react38.useEffect)(() => {
+  (0, import_react39.useEffect)(() => {
     var _a;
     refs.setReference((_a = anchorRef == null ? void 0 : anchorRef.current) != null ? _a : null);
   }, []);
@@ -4318,7 +5611,7 @@ var timezone = "Europe/Oslo";
 // src/components/date-inputs/DatePicker/Calendar/CalendarCell.tsx
 var import_jsx_runtime192 = require("react/jsx-runtime");
 function CalendarCell({ date, state }) {
-  const ref = (0, import_react39.useRef)(null);
+  const ref = (0, import_react40.useRef)(null);
   const {
     buttonProps,
     cellProps,
@@ -4331,7 +5624,7 @@ function CalendarCell({ date, state }) {
   if (isDisabled) {
     return /* @__PURE__ */ (0, import_jsx_runtime192.jsx)("td", { ...cellProps });
   }
-  const { onClose } = (0, import_react39.useContext)(CalendarPopoverContext);
+  const { onClose } = (0, import_react40.useContext)(CalendarPopoverContext);
   const variant = isSelected ? "selected" : isUnavailable || isDisabled ? "unavailable" : "default";
   const closeOnKeyboardBlurForward = (event) => {
     if (event.key === "Tab" && event.shiftKey === false) {
@@ -4437,7 +5730,7 @@ function CalendarGrid({ state, ...props }) {
               }
             ),
             datesInWeek.map(
-              (date, i) => date ? /* @__PURE__ */ (0, import_jsx_runtime193.jsx)(CalendarCell, { state, date }, i) : /* @__PURE__ */ (0, import_jsx_runtime193.jsx)("td", {}, i)
+              (date, i2) => date ? /* @__PURE__ */ (0, import_jsx_runtime193.jsx)(CalendarCell, { state, date }, i2) : /* @__PURE__ */ (0, import_jsx_runtime193.jsx)("td", {}, i2)
             )
           ] }, weekIndex);
         }) })
@@ -4449,12 +5742,12 @@ CalendarGrid.displayName = "CalendarGrid";
 
 // src/components/date-inputs/DatePicker/Calendar/Calendar.tsx
 var import_jsx_runtime194 = require("react/jsx-runtime");
-function createCalendar(identifier) {
-  switch (identifier) {
+function createCalendar(identifier2) {
+  switch (identifier2) {
     case "gregory":
       return new import_date4.GregorianCalendar();
     default:
-      throw new Error(`Unsupported calendar ${identifier}`);
+      throw new Error(`Unsupported calendar ${identifier2}`);
   }
 }
 function Calendar(props) {
@@ -4470,7 +5763,7 @@ function Calendar(props) {
     nextButtonProps: { onPress: onNext, "aria-label": nextAriaLabel },
     title
   } = (0, import_calendar3.useCalendar)(props, state);
-  const { onClose } = (0, import_react40.useContext)(CalendarPopoverContext);
+  const { onClose } = (0, import_react41.useContext)(CalendarPopoverContext);
   const closeOnKeyboardBlurBack = (event) => {
     if (event.key === "Tab" && event.shiftKey === true) {
       onClose();
@@ -4522,24 +5815,24 @@ Calendar.displayName = "Calendar";
 var import_datepicker4 = require("@react-aria/datepicker");
 var import_i18n4 = require("@react-aria/i18n");
 var import_datepicker5 = require("@react-stately/datepicker");
-var import_react47 = require("react");
+var import_react48 = require("react");
 
 // src/components/date-inputs/DatePicker/DateField/DateField.tsx
 var import_date5 = require("@internationalized/date");
 var import_datepicker2 = require("@react-aria/datepicker");
 var import_i18n3 = require("@react-aria/i18n");
 var import_datepicker3 = require("@react-stately/datepicker");
-var import_react45 = require("react");
+var import_react46 = require("react");
 
 // src/components/date-inputs/DatePicker/DateField/CalendarButton.tsx
 var import_button = require("@react-aria/button");
-var import_react41 = require("react");
+var import_react42 = require("react");
 var import_jsx_runtime195 = require("react/jsx-runtime");
 function CalendarButton({
   componentSize,
   ...props
 }) {
-  const ref = (0, import_react41.useRef)(null);
+  const ref = (0, import_react42.useRef)(null);
   const { buttonProps } = (0, import_button.useButton)(props, ref);
   const size2 = componentSize === "medium" ? "medium" : "small";
   return /* @__PURE__ */ (0, import_jsx_runtime195.jsx)(
@@ -4569,7 +5862,7 @@ function CalendarButton({
 
 // src/components/date-inputs/DatePicker/DateField/DateSegment.tsx
 var import_datepicker = require("@react-aria/datepicker");
-var import_react42 = require("react");
+var import_react43 = require("react");
 var import_jsx_runtime196 = require("react/jsx-runtime");
 var typographyTypes2 = {
   medium: "bodySans02",
@@ -4587,7 +5880,7 @@ function DateSegment({
   componentSize
 }) {
   var _a;
-  const ref = (0, import_react42.useRef)(null);
+  const ref = (0, import_react43.useRef)(null);
   const { segmentProps } = (0, import_datepicker.useDateSegment)(segment, state, ref);
   return /* @__PURE__ */ (0, import_jsx_runtime196.jsxs)(
     "div",
@@ -4624,10 +5917,10 @@ function DateSegment({
 DateSegment.displayName = "DateSegment";
 
 // src/components/date-inputs/common/DateInput.tsx
-var import_react44 = require("react");
+var import_react45 = require("react");
 
 // src/components/InputMessage/InputMessage.tsx
-var import_react43 = require("react");
+var import_react44 = require("react");
 
 // src/components/InputMessage/InputMessage.module.css
 var InputMessage_default = {
@@ -4639,7 +5932,7 @@ var InputMessage_default = {
 
 // src/components/InputMessage/InputMessage.tsx
 var import_jsx_runtime197 = require("react/jsx-runtime");
-var InputMessage = (0, import_react43.forwardRef)(
+var InputMessage = (0, import_react44.forwardRef)(
   (props, ref) => {
     const { message, messageType, id, className, htmlProps, ...rest } = props;
     const isError = messageType === "error";
@@ -4707,7 +6000,7 @@ function _DateInput({
   const hasTip = !!tip;
   const hasLabel = props.label != null;
   const hasMessage = hasErrorMessage || hasTip;
-  const { isOpen } = (0, import_react44.useContext)(CalendarPopoverContext);
+  const { isOpen } = (0, import_react45.useContext)(CalendarPopoverContext);
   return /* @__PURE__ */ (0, import_jsx_runtime198.jsxs)(
     "div",
     {
@@ -4759,7 +6052,7 @@ function _DateInput({
     }
   );
 }
-var DateInput = (0, import_react44.forwardRef)(_DateInput);
+var DateInput = (0, import_react45.forwardRef)(_DateInput);
 DateInput.displayName = "DateInput";
 
 // src/components/date-inputs/DatePicker/DateField/DateField.tsx
@@ -4776,7 +6069,7 @@ function _DateField({
     locale: locale2,
     createCalendar: import_date5.createCalendar
   });
-  const ref = (0, import_react45.useRef)(null);
+  const ref = (0, import_react46.useRef)(null);
   const { labelProps, fieldProps } = (0, import_datepicker2.useDateField)(props, state, ref);
   const disabled = props.isDisabled || !!fieldProps["aria-disabled"];
   return /* @__PURE__ */ (0, import_jsx_runtime199.jsx)(
@@ -4801,27 +6094,27 @@ function _DateField({
       ),
       labelProps,
       fieldProps,
-      children: state.segments.map((segment, i) => /* @__PURE__ */ (0, import_jsx_runtime199.jsx)(
+      children: state.segments.map((segment, i2) => /* @__PURE__ */ (0, import_jsx_runtime199.jsx)(
         DateSegment,
         {
           componentSize,
           segment,
           state
         },
-        i
+        i2
       ))
     }
   );
 }
-var DateField = (0, import_react45.forwardRef)(_DateField);
+var DateField = (0, import_react46.forwardRef)(_DateField);
 DateField.displayName = "DateField";
 
 // src/components/date-inputs/utils/useFocusManagerRef.ts
 var import_focus11 = require("@react-aria/focus");
-var import_react46 = require("react");
+var import_react47 = require("react");
 function useFocusManagerRef(ref) {
-  const domRef = (0, import_react46.useRef)(null);
-  (0, import_react46.useImperativeHandle)(ref, () => ({
+  const domRef = (0, import_react47.useRef)(null);
+  (0, import_react47.useImperativeHandle)(ref, () => ({
     ...createDOMRef(domRef),
     focus() {
       (0, import_focus11.createFocusManager)(domRef).focusFirst({ tabbable: true });
@@ -4845,9 +6138,9 @@ var refIsFocusable = (ref) => {
 function _DatePicker({ errorMessage, componentSize, tip, style, width, ...props }, forwardedRef) {
   const state = (0, import_datepicker5.useDatePickerState)(props);
   const domRef = useFocusManagerRef(
-    refIsFocusable(import_react47.forwardRef) ? forwardedRef : null
+    refIsFocusable(import_react48.forwardRef) ? forwardedRef : null
   );
-  const ref = (0, import_react47.useRef)(null);
+  const ref = (0, import_react48.useRef)(null);
   const combinedRef = useCombinedRef(ref, domRef);
   const { buttonProps, calendarProps, fieldProps, groupProps } = (0, import_datepicker4.useDatePicker)(
     { ...props, granularity: "day" },
@@ -4874,16 +6167,16 @@ function _DatePicker({ errorMessage, componentSize, tip, style, width, ...props
     /* @__PURE__ */ (0, import_jsx_runtime200.jsx)(CalendarPopoverContent, { children: /* @__PURE__ */ (0, import_jsx_runtime200.jsx)(Calendar, { ...calendarProps }) })
   ] }) });
 }
-var DatePicker = (0, import_react47.forwardRef)(_DatePicker);
+var DatePicker = (0, import_react48.forwardRef)(_DatePicker);
 DatePicker.displayName = "DatePicker";
 
 // src/components/date-inputs/TimePicker/TimePicker.tsx
 var import_datepicker6 = require("@react-aria/datepicker");
 var import_datepicker7 = require("@react-stately/datepicker");
-var import_react48 = require("react");
+var import_react49 = require("react");
 var import_jsx_runtime201 = require("react/jsx-runtime");
 function _TimePicker({ componentSize = "medium", width, ...props }, forwardedRef) {
-  const ref = (0, import_react48.useRef)(null);
+  const ref = (0, import_react49.useRef)(null);
   const state = (0, import_datepicker7.useTimeFieldState)({
     ...props,
     locale
@@ -4918,19 +6211,19 @@ function _TimePicker({ componentSize = "medium", width, ...props }, forwardedRef
           children: /* @__PURE__ */ (0, import_jsx_runtime201.jsx)(Icon, { icon: TimeIcon, iconSize })
         }
       ),
-      children: state.segments.map((segment, i) => /* @__PURE__ */ (0, import_jsx_runtime201.jsx)(
+      children: state.segments.map((segment, i2) => /* @__PURE__ */ (0, import_jsx_runtime201.jsx)(
         DateSegment,
         {
           componentSize,
           segment,
           state
         },
-        i
+        i2
       ))
     }
   );
 }
-var TimePicker = (0, import_react48.forwardRef)(_TimePicker);
+var TimePicker = (0, import_react49.forwardRef)(_TimePicker);
 TimePicker.displayName = "TimePicker";
 
 // src/components/date-inputs/utils/transform.ts
@@ -4963,7 +6256,7 @@ function calendarDateToNativeDate(date, time = new import_date6.Time(12, 0, 0, 0
 }
 
 // src/components/DescriptionList/DescriptionList.tsx
-var import_react49 = require("react");
+var import_react50 = require("react");
 
 // src/components/DescriptionList/DescriptionList.module.css
 var DescriptionList_default = {
@@ -4978,7 +6271,7 @@ var DescriptionList_default = {
 
 // src/components/DescriptionList/DescriptionList.tsx
 var import_jsx_runtime202 = require("react/jsx-runtime");
-var DescriptionList = (0, import_react49.forwardRef)((props, ref) => {
+var DescriptionList = (0, import_react50.forwardRef)((props, ref) => {
   const {
     appearance = "default",
     direction = "column",
@@ -5010,17 +6303,17 @@ var DescriptionList = (0, import_react49.forwardRef)((props, ref) => {
 DescriptionList.displayName = "DescriptionList";
 
 // src/components/DescriptionList/DescriptionListTerm.tsx
-var import_react50 = require("react");
+var import_react51 = require("react");
 var import_jsx_runtime203 = require("react/jsx-runtime");
-var DescriptionListTerm = (0, import_react50.forwardRef)(({ ...rest }, ref) => {
+var DescriptionListTerm = (0, import_react51.forwardRef)(({ ...rest }, ref) => {
   return /* @__PURE__ */ (0, import_jsx_runtime203.jsx)("dt", { ref, ...rest });
 });
 DescriptionListTerm.displayName = "DescriptionListTerm";
 
 // src/components/DescriptionList/DescriptionListDesc.tsx
-var import_react51 = require("react");
+var import_react52 = require("react");
 var import_jsx_runtime204 = require("react/jsx-runtime");
-var DescriptionListDesc = (0, import_react51.forwardRef)((props, ref) => {
+var DescriptionListDesc = (0, import_react52.forwardRef)((props, ref) => {
   const { children, icon: icon2, id, className, htmlProps, ...rest } = props;
   return /* @__PURE__ */ (0, import_jsx_runtime204.jsxs)(
     "dd",
@@ -5038,9 +6331,9 @@ var DescriptionListDesc = (0, import_react51.forwardRef)((props, ref) => {
 DescriptionListDesc.displayName = "DescriptionListDesc";
 
 // src/components/DescriptionList/DescriptionListGroup.tsx
-var import_react52 = require("react");
+var import_react53 = require("react");
 var import_jsx_runtime205 = require("react/jsx-runtime");
-var DescriptionListGroup = (0, import_react52.forwardRef)((props, ref) => {
+var DescriptionListGroup = (0, import_react53.forwardRef)((props, ref) => {
   const {
     children,
     margin,
@@ -5064,7 +6357,7 @@ var DescriptionListGroup = (0, import_react52.forwardRef)((props, ref) => {
 DescriptionListGroup.displayName = "DescriptionListGroup";
 
 // src/components/Drawer/Drawer.tsx
-var import_react53 = require("react");
+var import_react54 = require("react");
 var import_react_dom2 = require("react-dom");
 
 // src/components/Drawer/Drawer.module.css
@@ -5085,7 +6378,7 @@ var Drawer_default = {
 
 // src/components/Drawer/Drawer.tsx
 var import_jsx_runtime206 = require("react/jsx-runtime");
-var Drawer = (0, import_react53.forwardRef)((props, ref) => {
+var Drawer = (0, import_react54.forwardRef)((props, ref) => {
   const {
     children,
     onClose,
@@ -5101,7 +6394,7 @@ var Drawer = (0, import_react53.forwardRef)((props, ref) => {
     widthProps,
     ...rest
   } = props;
-  const generatedId = (0, import_react53.useId)();
+  const generatedId = (0, import_react54.useId)();
   const uniqueId = id != null ? id : `${generatedId}-drawer`;
   const hasHeader = !!header;
   const headerId = hasHeader ? `${uniqueId}-header` : void 0;
@@ -5180,7 +6473,7 @@ var Drawer = (0, import_react53.forwardRef)((props, ref) => {
 Drawer.displayName = "Drawer";
 
 // src/components/Drawer/DrawerGroup.tsx
-var import_react54 = require("react");
+var import_react55 = require("react");
 var import_jsx_runtime207 = require("react/jsx-runtime");
 var DrawerGroup = ({
   children,
@@ -5188,10 +6481,10 @@ var DrawerGroup = ({
   onOpen,
   onClose
 }) => {
-  const generatedId = (0, import_react54.useId)();
+  const generatedId = (0, import_react55.useId)();
   const uniqueDrawerId = drawerId != null ? drawerId : `${generatedId}-drawer`;
-  const buttonRef = (0, import_react54.useRef)(null);
-  const [closed, setClosed] = (0, import_react54.useState)(true);
+  const buttonRef = (0, import_react55.useRef)(null);
+  const [closed, setClosed] = (0, import_react55.useState)(true);
   const open = () => setClosed(false);
   const close = () => setClosed(true);
   const handleOpen = () => {
@@ -5202,14 +6495,14 @@ var DrawerGroup = ({
     close();
     onClose && onClose();
   };
-  const Children8 = import_react54.Children.map(children, (child, childIndex) => {
-    return (0, import_react54.isValidElement)(child) && (childIndex === 0 ? (0, import_react54.cloneElement)(child, {
+  const Children8 = import_react55.Children.map(children, (child, childIndex) => {
+    return (0, import_react55.isValidElement)(child) && (childIndex === 0 ? (0, import_react55.cloneElement)(child, {
       "aria-haspopup": "dialog",
       "aria-controls": uniqueDrawerId,
       "aria-expanded": !closed,
       ref: buttonRef,
       onClick: handleOpen
-    }) : (0, import_react54.cloneElement)(child, {
+    }) : (0, import_react55.cloneElement)(child, {
       id: uniqueDrawerId,
       triggerRef: buttonRef,
       isOpen: !closed,
@@ -5248,7 +6541,7 @@ function EmptyContent({
 EmptyContent.displayName = "EmptyContent";
 
 // src/components/FavStar/FavStar.tsx
-var import_react57 = require("react");
+var import_react58 = require("react");
 
 // src/components/FavStar/FavStar.module.css
 var FavStar_default = {
@@ -5260,16 +6553,16 @@ var FavStar_default = {
 };
 
 // src/hooks/useControllableState.ts
-var import_react56 = require("react");
+var import_react57 = require("react");
 
 // src/hooks/useCallbackRef.ts
-var import_react55 = require("react");
+var import_react56 = require("react");
 function useCallbackRef(callback, deps = []) {
-  const callbackRef = (0, import_react55.useRef)(callback);
-  (0, import_react55.useEffect)(() => {
+  const callbackRef = (0, import_react56.useRef)(callback);
+  (0, import_react56.useEffect)(() => {
     callbackRef.current = callback;
   });
-  return (0, import_react55.useCallback)((...args) => {
+  return (0, import_react56.useCallback)((...args) => {
     var _a;
     return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
   }, deps);
@@ -5279,13 +6572,13 @@ function useCallbackRef(callback, deps = []) {
 function useControllableState(props) {
   const { value: valueProp, defaultValue, onChange } = props;
   const onChangeProp = useCallbackRef(onChange);
-  const [uncontrolledState, setUncontrolledState] = (0, import_react56.useState)(defaultValue);
+  const [uncontrolledState, setUncontrolledState] = (0, import_react57.useState)(defaultValue);
   const controlled = valueProp !== void 0;
   const value = controlled ? valueProp : uncontrolledState;
   const setValue = useCallbackRef(
-    (next) => {
-      const setter = next;
-      const nextValue = typeof next === "function" ? setter(value) : next;
+    (next2) => {
+      const setter = next2;
+      const nextValue = typeof next2 === "function" ? setter(value) : next2;
       if (!controlled) {
         setUncontrolledState(nextValue);
       }
@@ -5298,7 +6591,7 @@ function useControllableState(props) {
 
 // src/components/FavStar/FavStar.tsx
 var import_jsx_runtime209 = require("react/jsx-runtime");
-var FavStar = (0, import_react57.forwardRef)(
+var FavStar = (0, import_react58.forwardRef)(
   ({
     id,
     className,
@@ -5316,7 +6609,7 @@ var FavStar = (0, import_react57.forwardRef)(
       htmlProps,
       rest
     );
-    const generatedId = (0, import_react57.useId)();
+    const generatedId = (0, import_react58.useId)();
     const [checked, setChecked] = useControllableState({
       value: checkedProp,
       defaultValue: defaultChecked != null ? defaultChecked : false,
@@ -5364,7 +6657,7 @@ var FavStar = (0, import_react57.forwardRef)(
 FavStar.displayName = "FavStar";
 
 // src/components/Feedback/Feedback.tsx
-var import_react61 = require("react");
+var import_react62 = require("react");
 
 // src/components/Feedback/CommentComponent.tsx
 var import_dds_design_tokens15 = require("@norges-domstoler/dds-design-tokens");
@@ -5379,7 +6672,7 @@ var Feedback_default = {
 };
 
 // src/components/Stack/Stack.tsx
-var import_react58 = require("react");
+var import_react59 = require("react");
 
 // src/components/Stack/Stack.module.css
 var Stack_default = {
@@ -5416,7 +6709,7 @@ var Stack_default = {
 
 // src/components/Stack/Stack.tsx
 var import_jsx_runtime210 = require("react/jsx-runtime");
-var HStack = (0, import_react58.forwardRef)(
+var HStack = (0, import_react59.forwardRef)(
   ({
     id,
     className,
@@ -5455,7 +6748,7 @@ var HStack = (0, import_react58.forwardRef)(
   }
 );
 HStack.displayName = "HStack";
-var VStack = (0, import_react58.forwardRef)(
+var VStack = (0, import_react59.forwardRef)(
   ({
     id,
     className,
@@ -5499,7 +6792,7 @@ function spacingPropToCn(value) {
 }
 
 // src/components/TextArea/TextArea.tsx
-var import_react59 = require("react");
+var import_react60 = require("react");
 
 // src/components/TextArea/TextArea.module.css
 var TextArea_default = {
@@ -5509,7 +6802,7 @@ var TextArea_default = {
 
 // src/components/TextArea/TextArea.tsx
 var import_jsx_runtime211 = require("react/jsx-runtime");
-var TextArea = (0, import_react59.forwardRef)(
+var TextArea = (0, import_react60.forwardRef)(
   (props, ref) => {
     const {
       id,
@@ -5528,14 +6821,14 @@ var TextArea = (0, import_react59.forwardRef)(
       width,
       ...rest
     } = props;
-    const generatedId = (0, import_react59.useId)();
+    const generatedId = (0, import_react60.useId)();
     const uniqueId = id != null ? id : `${generatedId}-textArea`;
-    const textAreaRef = (0, import_react59.useRef)(null);
+    const textAreaRef = (0, import_react60.useRef)(null);
     const multiRef = useCombinedRef(ref, textAreaRef);
-    const [text, setText] = (0, import_react59.useState)(
+    const [text, setText] = (0, import_react60.useState)(
       getDefaultText(value, defaultValue)
     );
-    (0, import_react59.useEffect)(() => {
+    (0, import_react60.useEffect)(() => {
       if (textAreaRef == null ? void 0 : textAreaRef.current) {
         textAreaRef.current.style.height = `${textAreaRef.current.scrollHeight + 2}px`;
       }
@@ -5648,7 +6941,7 @@ var CommentComponent = ({
 };
 
 // src/components/Tooltip/Tooltip.tsx
-var import_react60 = require("react");
+var import_react61 = require("react");
 
 // src/components/Tooltip/Tooltip.module.css
 var Tooltip_default = {
@@ -5660,7 +6953,7 @@ var Tooltip_default = {
 
 // src/components/Tooltip/Tooltip.tsx
 var import_jsx_runtime213 = require("react/jsx-runtime");
-var Tooltip = (0, import_react60.forwardRef)(
+var Tooltip = (0, import_react61.forwardRef)(
   (props, ref) => {
     const {
       text,
@@ -5676,21 +6969,21 @@ var Tooltip = (0, import_react60.forwardRef)(
       htmlProps,
       ...rest
     } = props;
-    const generatedId = (0, import_react60.useId)();
+    const generatedId = (0, import_react61.useId)();
     const uniqueTooltipId = tooltipId != null ? tooltipId : `${generatedId}-tooltip`;
-    const [open, setOpen] = (0, import_react60.useState)(false);
-    const [inView, setInView] = (0, import_react60.useState)(false);
-    const [arrowElement, setArrowElement] = (0, import_react60.useState)(null);
+    const [open, setOpen] = (0, import_react61.useState)(false);
+    const [inView, setInView] = (0, import_react61.useState)(false);
+    const [arrowElement, setArrowElement] = (0, import_react61.useState)(null);
     const { refs, styles: positionStyles } = useFloatPosition(arrowElement, {
       placement
     });
-    const tooltipRef = (0, import_react60.useRef)(null);
+    const tooltipRef = (0, import_react61.useRef)(null);
     const combinedRef = useCombinedRef(ref, refs.setFloating, tooltipRef);
     const closeWhenNotInView = (entries) => {
       const [entry] = entries;
       entry.isIntersecting ? setInView(true) : setInView(false);
     };
-    (0, import_react60.useEffect)(() => {
+    (0, import_react61.useEffect)(() => {
       const options = {
         root: null,
         rootMargin: "0px"
@@ -5702,7 +6995,7 @@ var Tooltip = (0, import_react60.forwardRef)(
         if (ref2) observer.unobserve(ref2);
       };
     }, [tooltipRef]);
-    (0, import_react60.useEffect)(() => {
+    (0, import_react61.useEffect)(() => {
       if (tooltipRef.current) {
         window.addEventListener("scroll", () => {
           closeTooltip();
@@ -5715,7 +7008,7 @@ var Tooltip = (0, import_react60.forwardRef)(
       };
     }, []);
     let timer;
-    (0, import_react60.useEffect)(() => {
+    (0, import_react61.useEffect)(() => {
       return () => {
         clearTimeout(timer);
       };
@@ -5734,8 +7027,8 @@ var Tooltip = (0, import_react60.forwardRef)(
       }
     };
     const anchorProps = children.props;
-    const anchorElement = import_react60.Children.only(
-      (0, import_react60.isValidElement)(children) && (0, import_react60.cloneElement)(children, {
+    const anchorElement = import_react61.Children.only(
+      (0, import_react61.isValidElement)(children) && (0, import_react61.cloneElement)(children, {
         ref: refs.setReference,
         onFocus: combineHandlers(openTooltip, anchorProps.onFocus),
         onBlur: combineHandlers(closeTooltip, anchorProps.onBlur),
@@ -5869,16 +7162,16 @@ var Feedback = ({
   onFeedbackTextChange,
   onSubmit
 }) => {
-  const [rating, setRating] = (0, import_react61.useState)(null);
-  const [feedbackText, setFeedbackText] = (0, import_react61.useState)();
-  const [isFeedbackSubmitted, setIsFeedbackSubmitted] = (0, import_react61.useState)(false);
-  (0, import_react61.useEffect)(() => {
+  const [rating, setRating] = (0, import_react62.useState)(null);
+  const [feedbackText, setFeedbackText] = (0, import_react62.useState)();
+  const [isFeedbackSubmitted, setIsFeedbackSubmitted] = (0, import_react62.useState)(false);
+  (0, import_react62.useEffect)(() => {
     ratingProp !== void 0 && setRating(ratingProp);
   }, [ratingProp]);
-  (0, import_react61.useEffect)(() => {
+  (0, import_react62.useEffect)(() => {
     feedbackTextProp !== void 0 && setFeedbackText(feedbackTextProp);
   }, [feedbackTextProp]);
-  (0, import_react61.useEffect)(() => {
+  (0, import_react62.useEffect)(() => {
     isSubmittedProp !== void 0 && setIsFeedbackSubmitted(isSubmittedProp);
   }, [isSubmittedProp]);
   const handleRatingChange = (newRating) => {
@@ -5927,7 +7220,7 @@ var Feedback = ({
 };
 
 // src/components/Fieldset/Fieldset.tsx
-var import_react62 = require("react");
+var import_react63 = require("react");
 
 // src/components/Fieldset/Fieldset.module.css
 var Fieldset_default = {
@@ -5936,7 +7229,7 @@ var Fieldset_default = {
 
 // src/components/Fieldset/Fieldset.tsx
 var import_jsx_runtime216 = require("react/jsx-runtime");
-var Fieldset = (0, import_react62.forwardRef)(
+var Fieldset = (0, import_react63.forwardRef)(
   (props, ref) => {
     const { id, className, htmlProps, ...rest } = props;
     return /* @__PURE__ */ (0, import_jsx_runtime216.jsx)(
@@ -5955,7 +7248,7 @@ var Fieldset = (0, import_react62.forwardRef)(
 );
 
 // src/components/FileUploader/FileUploader.tsx
-var import_react64 = require("react");
+var import_react65 = require("react");
 
 // src/components/FileUploader/ErrorList.tsx
 var import_jsx_runtime217 = require("react/jsx-runtime");
@@ -6035,7 +7328,7 @@ var File = (props) => {
 
 // src/components/FileUploader/useFileUploader.ts
 var import_file_selector = require("file-selector");
-var import_react63 = require("react");
+var import_react64 = require("react");
 
 // src/components/FileUploader/fileUploaderReducer.ts
 var fileUploaderReducer = (state, action) => {
@@ -6134,18 +7427,18 @@ var useFileUploader = (props) => {
     disabled,
     errorMessage
   } = props;
-  const rootRef = (0, import_react63.useRef)(null);
-  const inputRef = (0, import_react63.useRef)(null);
-  const buttonRef = (0, import_react63.useRef)(null);
+  const rootRef = (0, import_react64.useRef)(null);
+  const inputRef = (0, import_react64.useRef)(null);
+  const buttonRef = (0, import_react64.useRef)(null);
   const isControlled = !!value;
-  const initialFileUploaderFiles = (0, import_react63.useMemo)(
-    () => (initialFiles != null ? initialFiles : []).map((f) => ({
-      file: f,
+  const initialFileUploaderFiles = (0, import_react64.useMemo)(
+    () => (initialFiles != null ? initialFiles : []).map((f2) => ({
+      file: f2,
       errors: []
     })),
     [initialFiles]
   );
-  const [state, dispatch] = (0, import_react63.useReducer)(fileUploaderReducer, {
+  const [state, dispatch] = (0, import_react64.useReducer)(fileUploaderReducer, {
     files: initialFileUploaderFiles,
     isFocused: false,
     isFileDialogActive: false,
@@ -6157,7 +7450,7 @@ var useFileUploader = (props) => {
     )
   });
   const { files: stateFiles } = state;
-  (0, import_react63.useEffect)(() => {
+  (0, import_react64.useEffect)(() => {
     if (isControlled) {
       const files = value.map((file) => {
         const accepted = isFileAccepted(file, accept);
@@ -6172,18 +7465,18 @@ var useFileUploader = (props) => {
       });
     }
   }, [value, isControlled, accept, dispatch]);
-  (0, import_react63.useEffect)(() => {
+  (0, import_react64.useEffect)(() => {
     dispatch({
       type: "setRootErrors",
       payload: calcRootErrors(stateFiles, maxFiles, errorMessage)
     });
   }, [dispatch, stateFiles, maxFiles, errorMessage]);
-  const onRootFocus = (0, import_react63.useCallback)(
+  const onRootFocus = (0, import_react64.useCallback)(
     () => dispatch({ type: "focus" }),
     [dispatch]
   );
-  const onRootBlur = (0, import_react63.useCallback)(() => dispatch({ type: "blur" }), [dispatch]);
-  const onRootDragEnter = (0, import_react63.useCallback)(
+  const onRootBlur = (0, import_react64.useCallback)(() => dispatch({ type: "blur" }), [dispatch]);
+  const onRootDragEnter = (0, import_react64.useCallback)(
     async (evt) => {
       preventDefaults(evt);
       if (isEventWithFiles(evt)) {
@@ -6195,7 +7488,7 @@ var useFileUploader = (props) => {
     },
     [dispatch, accept, maxFiles]
   );
-  const onRootDragOver = (0, import_react63.useCallback)((evt) => {
+  const onRootDragOver = (0, import_react64.useCallback)((evt) => {
     preventDefaults(evt);
     const hasFiles = isEventWithFiles(evt);
     if (hasFiles && evt.dataTransfer) {
@@ -6205,7 +7498,7 @@ var useFileUploader = (props) => {
       }
     }
   }, []);
-  const onRootDragLeave = (0, import_react63.useCallback)(
+  const onRootDragLeave = (0, import_react64.useCallback)(
     (evt) => {
       preventDefaults(evt);
       if (evt.currentTarget.contains(evt.relatedTarget)) return;
@@ -6213,22 +7506,22 @@ var useFileUploader = (props) => {
     },
     [dispatch]
   );
-  const setFiles = (0, import_react63.useCallback)(
+  const setFiles = (0, import_react64.useCallback)(
     async (evt) => {
       evt.preventDefault();
       if (isEventWithFiles(evt)) {
-        const existingFileNames = stateFiles.map((f) => f.file.name);
+        const existingFileNames = stateFiles.map((f2) => f2.file.name);
         const filesFromEvent = await (0, import_file_selector.fromEvent)(
           evt
         );
-        const newFiles = filesFromEvent.filter((f) => !existingFileNames.includes(f.name)).map((file) => {
+        const newFiles = filesFromEvent.filter((f2) => !existingFileNames.includes(f2.name)).map((file) => {
           const accepted = isFileAccepted(file, accept);
           return {
             file,
             errors: accepted ? [] : [getInvalidFileTypeErrorMessage()]
           };
         }).concat(stateFiles);
-        onChange(newFiles.map((f) => f.file));
+        onChange(newFiles.map((f2) => f2.file));
         if (!isControlled) {
           dispatch({
             type: "onSetFiles",
@@ -6247,17 +7540,17 @@ var useFileUploader = (props) => {
       dispatch
     ]
   );
-  const openFileDialog = (0, import_react63.useCallback)(() => {
+  const openFileDialog = (0, import_react64.useCallback)(() => {
     if (inputRef.current) {
       inputRef.current.value = "";
       inputRef.current.click();
     }
   }, [inputRef]);
-  const removeFile = (0, import_react63.useCallback)(
+  const removeFile = (0, import_react64.useCallback)(
     (file) => {
       const newFiles = [...stateFiles];
       newFiles.splice(stateFiles.indexOf(file), 1);
-      onChange(newFiles.map((f) => f.file));
+      onChange(newFiles.map((f2) => f2.file));
       if (!isControlled) {
         dispatch({
           type: "onRemoveFile",
@@ -6267,7 +7560,7 @@ var useFileUploader = (props) => {
     },
     [stateFiles, isControlled, maxFiles, errorMessage, onChange, dispatch]
   );
-  const getRootProps = (0, import_react63.useCallback)(
+  const getRootProps = (0, import_react64.useCallback)(
     () => ({
       onBlur: onRootBlur,
       onFocus: onRootFocus,
@@ -6289,14 +7582,14 @@ var useFileUploader = (props) => {
       disabled
     ]
   );
-  const getButtonProps = (0, import_react63.useCallback)(
+  const getButtonProps = (0, import_react64.useCallback)(
     () => ({
       onClick: openFileDialog,
       ref: buttonRef
     }),
     [openFileDialog, buttonRef]
   );
-  const getInputProps = (0, import_react63.useCallback)(
+  const getInputProps = (0, import_react64.useCallback)(
     () => ({
       type: "file",
       style: { display: "none" },
@@ -6354,7 +7647,7 @@ var FileUploader = (props) => {
     className,
     ...rest
   } = props;
-  const generatedId = (0, import_react64.useId)();
+  const generatedId = (0, import_react65.useId)();
   const uniqueId = id != null ? id : `${generatedId}-fileUploader`;
   const {
     state: { files: stateFiles, isDragActive, rootErrors },
@@ -6461,7 +7754,7 @@ var FileUploader = (props) => {
 FileUploader.displayName = "FileUploader";
 
 // src/components/GlobalMessage/GlobalMessage.tsx
-var import_react65 = require("react");
+var import_react66 = require("react");
 
 // src/components/GlobalMessage/GlobalMessage.module.css
 var GlobalMessage_default = {
@@ -6487,7 +7780,7 @@ var purposeVariants = {
     icon: WarningIcon
   }
 };
-var GlobalMessage = (0, import_react65.forwardRef)(
+var GlobalMessage = (0, import_react66.forwardRef)(
   (props, ref) => {
     const {
       message,
@@ -6500,7 +7793,7 @@ var GlobalMessage = (0, import_react65.forwardRef)(
       htmlProps,
       ...rest
     } = props;
-    const [isClosed, setClosed] = (0, import_react65.useState)(false);
+    const [isClosed, setClosed] = (0, import_react66.useState)(false);
     return !isClosed ? /* @__PURE__ */ (0, import_jsx_runtime221.jsxs)(
       "div",
       {
@@ -6674,7 +7967,7 @@ var GridChild = (props) => {
 GridChild.displayName = "GridChild";
 
 // src/components/InlineButton/InlineButton.tsx
-var import_react66 = require("react");
+var import_react67 = require("react");
 
 // src/components/InlineButton/InlineButton.module.css
 var InlineButton_default = {
@@ -6683,7 +7976,7 @@ var InlineButton_default = {
 
 // src/components/InlineButton/InlineButton.tsx
 var import_jsx_runtime224 = require("react/jsx-runtime");
-var InlineButton = (0, import_react66.forwardRef)(
+var InlineButton = (0, import_react67.forwardRef)(
   (props, ref) => {
     const { className, ...rest } = props;
     return /* @__PURE__ */ (0, import_jsx_runtime224.jsx)(
@@ -6705,10 +7998,10 @@ var InlineButton = (0, import_react66.forwardRef)(
 );
 
 // src/components/InlineEdit/InlineEditTextArea.tsx
-var import_react69 = require("react");
+var import_react70 = require("react");
 
 // src/components/InlineEdit/InlineEdit.tsx
-var import_react67 = require("react");
+var import_react68 = require("react");
 var import_jsx_runtime225 = require("react/jsx-runtime");
 var InlineEdit = (props) => {
   const {
@@ -6721,8 +8014,8 @@ var InlineEdit = (props) => {
     inputRef,
     children
   } = props;
-  const [editingValue, setEditingValue] = (0, import_react67.useState)(value != null ? value : "");
-  const [isEditing, setIsEditing] = (0, import_react67.useState)(false);
+  const [editingValue, setEditingValue] = (0, import_react68.useState)(value != null ? value : "");
+  const [isEditing, setIsEditing] = (0, import_react68.useState)(false);
   const onChangeHandler = (e) => {
     setEditingValue(e.target.value);
     onChange && onChange();
@@ -6749,8 +8042,8 @@ var InlineEdit = (props) => {
   useOnKeyDown(["Enter"], () => onExitHandler());
   useOnKeyDown(["Escape"], () => onExitHandler());
   useOnClickOutside(inputRef.current, () => onExitHandler());
-  const inputChild = import_react67.Children.only(
-    (0, import_react67.isValidElement)(children) && (0, import_react67.cloneElement)(children, {
+  const inputChild = import_react68.Children.only(
+    (0, import_react68.isValidElement)(children) && (0, import_react68.cloneElement)(children, {
       onChange: onChangeHandler,
       onBlur: onBlurHandler,
       onFocus: onFocusHandler,
@@ -6764,7 +8057,7 @@ var InlineEdit = (props) => {
 InlineEdit.displayName = "InlineEdit";
 
 // src/components/InlineEdit/InlineTextArea.tsx
-var import_react68 = require("react");
+var import_react69 = require("react");
 
 // src/components/InlineEdit/InlineEdit.module.css
 var InlineEdit_default = {
@@ -6786,7 +8079,7 @@ var inlineEditVisuallyHidden = (id, emptiable) => /* @__PURE__ */ (0, import_jsx
 
 // src/components/InlineEdit/InlineTextArea.tsx
 var import_jsx_runtime227 = require("react/jsx-runtime");
-var InlineTextArea = (0, import_react68.forwardRef)((props, ref) => {
+var InlineTextArea = (0, import_react69.forwardRef)((props, ref) => {
   const {
     id,
     error,
@@ -6798,14 +8091,14 @@ var InlineTextArea = (0, import_react68.forwardRef)((props, ref) => {
     hideIcon,
     ...rest
   } = props;
-  const genereatedId = (0, import_react68.useId)();
+  const genereatedId = (0, import_react69.useId)();
   const uniqueId = id != null ? id : `${genereatedId}-InlineTextArea`;
   const hasErrorMessage = !!errorMessage;
   const errorMessageId = derivativeIdGenerator(uniqueId, "errorMessage");
   const hasError = !!error;
   const hasErrorState = hasError || hasErrorMessage;
   const descId = derivativeIdGenerator(uniqueId, "desc");
-  const inputRef = (0, import_react68.useRef)(null);
+  const inputRef = (0, import_react69.useRef)(null);
   const combinedRef = useCombinedRef(ref, inputRef);
   return /* @__PURE__ */ (0, import_jsx_runtime227.jsxs)("div", { className: InlineEdit_default.container, style: { width }, children: [
     /* @__PURE__ */ (0, import_jsx_runtime227.jsxs)("div", { className: Input_default["input-group"], children: [
@@ -6853,9 +8146,9 @@ InlineTextArea.displayName = "InlineTextArea";
 
 // src/components/InlineEdit/InlineEditTextArea.tsx
 var import_jsx_runtime228 = require("react/jsx-runtime");
-var InlineEditTextArea = (0, import_react69.forwardRef)((props, ref) => {
+var InlineEditTextArea = (0, import_react70.forwardRef)((props, ref) => {
   const { onSetValue, emptiable, value, onFocus, onChange, onBlur, ...rest } = props;
-  const textareaRef = (0, import_react69.useRef)(null);
+  const textareaRef = (0, import_react70.useRef)(null);
   const combinedRef = useCombinedRef(ref, textareaRef);
   return /* @__PURE__ */ (0, import_jsx_runtime228.jsx)(
     InlineEdit,
@@ -6873,12 +8166,12 @@ var InlineEditTextArea = (0, import_react69.forwardRef)((props, ref) => {
 });
 
 // src/components/InlineEdit/InlineEditInput.tsx
-var import_react71 = require("react");
+var import_react72 = require("react");
 
 // src/components/InlineEdit/InlineInput.tsx
-var import_react70 = require("react");
+var import_react71 = require("react");
 var import_jsx_runtime229 = require("react/jsx-runtime");
-var InlineInput = (0, import_react70.forwardRef)(
+var InlineInput = (0, import_react71.forwardRef)(
   (props, ref) => {
     const {
       id,
@@ -6891,14 +8184,14 @@ var InlineInput = (0, import_react70.forwardRef)(
       hideIcon,
       ...rest
     } = props;
-    const genereatedId = (0, import_react70.useId)();
+    const genereatedId = (0, import_react71.useId)();
     const uniqueId = id != null ? id : `${genereatedId}-InlineInput`;
     const hasErrorMessage = !!errorMessage;
     const hasError = !!error;
     const hasErrorState = hasError || hasErrorMessage;
     const errorMessageId = derivativeIdGenerator(uniqueId, "errorMessage");
     const descId = derivativeIdGenerator(uniqueId, "desc");
-    const inputRef = (0, import_react70.useRef)(null);
+    const inputRef = (0, import_react71.useRef)(null);
     const combinedRef = useCombinedRef(ref, inputRef);
     return /* @__PURE__ */ (0, import_jsx_runtime229.jsxs)("div", { className: InlineEdit_default.container, style: { width }, children: [
       /* @__PURE__ */ (0, import_jsx_runtime229.jsxs)("div", { className: Input_default["input-group"], children: [
@@ -6945,9 +8238,9 @@ InlineInput.displayName = "InlineInput";
 
 // src/components/InlineEdit/InlineEditInput.tsx
 var import_jsx_runtime230 = require("react/jsx-runtime");
-var InlineEditInput = (0, import_react71.forwardRef)((props, ref) => {
+var InlineEditInput = (0, import_react72.forwardRef)((props, ref) => {
   const { onSetValue, emptiable, value, onFocus, onChange, onBlur, ...rest } = props;
-  const inputRef = (0, import_react71.useRef)(null);
+  const inputRef = (0, import_react72.useRef)(null);
   const combinedRef = useCombinedRef(ref, inputRef);
   return /* @__PURE__ */ (0, import_jsx_runtime230.jsx)(
     InlineEdit,
@@ -6965,7 +8258,7 @@ var InlineEditInput = (0, import_react71.forwardRef)((props, ref) => {
 });
 
 // src/components/InternalHeader/InternalHeader.tsx
-var import_react73 = require("react");
+var import_react74 = require("react");
 
 // src/components/InternalHeader/InternalHeader.module.css
 var InternalHeader_default = {
@@ -6983,9 +8276,9 @@ var InternalHeader_default = {
 };
 
 // src/components/InternalHeader/NavigationItem.tsx
-var import_react72 = require("react");
+var import_react73 = require("react");
 var import_jsx_runtime231 = require("react/jsx-runtime");
-var NavigationItem = (0, import_react72.forwardRef)(({ title, isCurrent, ...rest }, ref) => {
+var NavigationItem = (0, import_react73.forwardRef)(({ title, isCurrent, ...rest }, ref) => {
   return /* @__PURE__ */ (0, import_jsx_runtime231.jsx)(
     "a",
     {
@@ -7021,11 +8314,11 @@ var InternalHeader = (props) => {
     htmlProps,
     ...rest
   } = props;
-  const [contextMenuIsClosed, setContextMenuIsClosed] = (0, import_react73.useState)(true);
-  const [currentPage, setCurrentPage] = (0, import_react73.useState)(
+  const [contextMenuIsClosed, setContextMenuIsClosed] = (0, import_react74.useState)(true);
+  const [currentPage, setCurrentPage] = (0, import_react74.useState)(
     currentPageHref
   );
-  const buttonRef = (0, import_react73.useRef)(null);
+  const buttonRef = (0, import_react74.useRef)(null);
   const handleCurrentPageChange = (href) => {
     setCurrentPage(href);
     onCurrentPageChange && onCurrentPageChange();
@@ -7121,7 +8414,7 @@ var InternalHeader = (props) => {
 InternalHeader.displayName = "InternalHeader";
 
 // src/components/List/List.tsx
-var import_react74 = require("react");
+var import_react75 = require("react");
 
 // src/components/List/List.module.css
 var List_default = {
@@ -7134,7 +8427,7 @@ var List_default = {
 
 // src/components/List/List.tsx
 var import_jsx_runtime233 = require("react/jsx-runtime");
-var List = (0, import_react74.forwardRef)((props, ref) => {
+var List = (0, import_react75.forwardRef)((props, ref) => {
   const {
     listType = "unordered",
     typographyType = "inherit",
@@ -7162,9 +8455,9 @@ var List = (0, import_react74.forwardRef)((props, ref) => {
 List.displayName = "List";
 
 // src/components/List/ListItem.tsx
-var import_react75 = require("react");
+var import_react76 = require("react");
 var import_jsx_runtime234 = require("react/jsx-runtime");
-var ListItem = (0, import_react75.forwardRef)(
+var ListItem = (0, import_react76.forwardRef)(
   ({ className, ...rest }, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime234.jsx)("li", { ref, ...rest, className: cn(className, List_default.li) });
   }
@@ -7172,7 +8465,7 @@ var ListItem = (0, import_react75.forwardRef)(
 ListItem.displayName = "ListItem";
 
 // src/components/LocalMessage/LocalMessage.tsx
-var import_react76 = require("react");
+var import_react77 = require("react");
 
 // src/components/LocalMessage/LocalMessage.module.css
 var LocalMessage_default = {
@@ -7211,7 +8504,7 @@ var purposeVariants2 = {
     icon: TipIcon
   }
 };
-var LocalMessage = (0, import_react76.forwardRef)(
+var LocalMessage = (0, import_react77.forwardRef)(
   (props, ref) => {
     const {
       message,
@@ -7226,7 +8519,7 @@ var LocalMessage = (0, import_react76.forwardRef)(
       htmlProps,
       ...rest
     } = props;
-    const [isClosed, setClosed] = (0, import_react76.useState)(false);
+    const [isClosed, setClosed] = (0, import_react77.useState)(false);
     if (isClosed) {
       return /* @__PURE__ */ (0, import_jsx_runtime235.jsx)(import_jsx_runtime235.Fragment, {});
     }
@@ -7279,7 +8572,7 @@ var LocalMessage = (0, import_react76.forwardRef)(
 LocalMessage.displayName = "LocalMessage";
 
 // src/components/Modal/Modal.tsx
-var import_react77 = require("react");
+var import_react78 = require("react");
 var import_react_dom3 = require("react-dom");
 
 // src/components/Modal/Backdrop/Backdrop.utils.tsx
@@ -7318,7 +8611,7 @@ var Modal_default = {
 
 // src/components/Modal/Modal.tsx
 var import_jsx_runtime236 = require("react/jsx-runtime");
-var Modal = (0, import_react77.forwardRef)((props, ref) => {
+var Modal = (0, import_react78.forwardRef)((props, ref) => {
   const {
     isOpen = false,
     parentElement = document.body,
@@ -7332,7 +8625,7 @@ var Modal = (0, import_react77.forwardRef)((props, ref) => {
     htmlProps,
     ...rest
   } = props;
-  const generatedId = (0, import_react77.useId)();
+  const generatedId = (0, import_react78.useId)();
   const modalId = id != null ? id : `${generatedId}-modal`;
   const headerId = `${modalId}-header`;
   const modalRef = useFocusTrap(isOpen, initialFocusRef);
@@ -7344,7 +8637,7 @@ var Modal = (0, import_react77.forwardRef)((props, ref) => {
       onClose();
     }
   };
-  (0, import_react77.useEffect)(() => {
+  (0, import_react78.useEffect)(() => {
     if (isOpen) {
       handleElementWithBackdropMount(document.body);
     } else {
@@ -7407,9 +8700,9 @@ var Modal = (0, import_react77.forwardRef)((props, ref) => {
 Modal.displayName = "Modal";
 
 // src/components/Modal/ModalBody.tsx
-var import_react78 = require("react");
+var import_react79 = require("react");
 var import_jsx_runtime237 = require("react/jsx-runtime");
-var ModalBody = (0, import_react78.forwardRef)(
+var ModalBody = (0, import_react79.forwardRef)(
   (props, ref) => {
     const { children, id, className, scrollable, htmlProps, height, ...rest } = props;
     return /* @__PURE__ */ (0, import_jsx_runtime237.jsx)(
@@ -7436,9 +8729,9 @@ var ModalBody = (0, import_react78.forwardRef)(
 ModalBody.displayName = "ModalBody";
 
 // src/components/Modal/ModalActions.tsx
-var import_react79 = require("react");
+var import_react80 = require("react");
 var import_jsx_runtime238 = require("react/jsx-runtime");
-var ModalActions = (0, import_react79.forwardRef)(
+var ModalActions = (0, import_react80.forwardRef)(
   ({ className, ...rest }, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime238.jsx)("div", { ref, ...rest, className: cn(className, Modal_default.actions) });
   }
@@ -7446,7 +8739,7 @@ var ModalActions = (0, import_react79.forwardRef)(
 ModalActions.displayName = "ModalActions";
 
 // src/components/Pagination/Pagination.tsx
-var import_react81 = require("react");
+var import_react82 = require("react");
 
 // src/components/Pagination/Pagination.module.css
 var Pagination_default = {
@@ -7462,8 +8755,8 @@ var Pagination_default = {
 
 // src/components/Pagination/paginationGenerator.tsx
 var arrayRange = (start, end) => {
-  const length = end - start + 1;
-  return Array.from({ length }, (_, idx) => idx + start);
+  const length2 = end - start + 1;
+  return Array.from({ length: length2 }, (_2, idx) => idx + start);
 };
 function PaginationGenerator(pagesAmount, activePage) {
   const siblingsCount = 1;
@@ -7494,7 +8787,7 @@ function PaginationGenerator(pagesAmount, activePage) {
 }
 
 // src/components/Select/Select.tsx
-var import_react80 = require("react");
+var import_react81 = require("react");
 var import_react_select2 = __toESM(require("react-select"));
 
 // src/components/Select/Select.module.css
@@ -7684,7 +8977,7 @@ var {
   noOptionsMessage: noOptionsMessage2,
   valueContainer: valueContainer2
 } = selectTokens;
-var prefix = "dds-select";
+var prefix2 = "dds-select";
 function getContainerControlPadding(componentSize, isMulti) {
   return isMulti ? control2.isMulti.sizes[componentSize].padding : control2.sizes[componentSize].padding;
 }
@@ -7973,7 +9266,7 @@ function SelectInner(props, ref) {
     "data-testid": dataTestId,
     ...rest
   } = props;
-  const generatedId = (0, import_react80.useId)();
+  const generatedId = (0, import_react81.useId)();
   const uniqueId = id != null ? id : `${generatedId}-select`;
   const singleValueId = !isMulti ? `${uniqueId}-singleValue` : void 0;
   const hasLabel = !!label;
@@ -7992,7 +9285,7 @@ function SelectInner(props, ref) {
     isMulti,
     inputId: uniqueId,
     name: uniqueId,
-    classNamePrefix: prefix,
+    classNamePrefix: prefix2,
     styles: getCustomStyles(componentSize, hasErrorMessage, readOnly),
     filterOption: (option3, inputValue) => {
       const { label: label2 } = option3;
@@ -8038,15 +9331,15 @@ function SelectInner(props, ref) {
     }
   );
 }
-var Select = (0, import_react80.forwardRef)(SelectInner);
+var Select = (0, import_react81.forwardRef)(SelectInner);
 Select.displayName = "Select";
 
 // src/components/Select/utils.ts
-var createSelectOptions = (...args) => args.map((v) => ({ label: v, value: v }));
+var createSelectOptions = (...args) => args.map((v2) => ({ label: v2, value: v2 }));
 
 // src/components/Pagination/Pagination.tsx
 var import_jsx_runtime241 = require("react/jsx-runtime");
-var Pagination = (0, import_react81.forwardRef)(
+var Pagination = (0, import_react82.forwardRef)(
   (props, ref) => {
     const {
       itemsAmount,
@@ -8069,8 +9362,8 @@ var Pagination = (0, import_react81.forwardRef)(
       htmlProps,
       ...rest
     } = props;
-    const [activePage, setActivePage] = (0, import_react81.useState)(defaultActivePage);
-    const [itemsPerPage, setItemsPerPage] = (0, import_react81.useState)(defaultItemsPerPage);
+    const [activePage, setActivePage] = (0, import_react82.useState)(defaultActivePage);
+    const [itemsPerPage, setItemsPerPage] = (0, import_react82.useState)(defaultItemsPerPage);
     const pagesLength = Math.ceil(itemsAmount / itemsPerPage);
     const items = PaginationGenerator(pagesLength, activePage);
     const onPageChange = (event, page) => {
@@ -8087,7 +9380,7 @@ var Pagination = (0, import_react81.forwardRef)(
         onSelectOptionChange(option3);
       }
     };
-    const listItems = items.length > 0 ? items.map((item, i) => {
+    const listItems = items.length > 0 ? items.map((item, i2) => {
       const isActive = item === activePage;
       return /* @__PURE__ */ (0, import_jsx_runtime241.jsx)("li", { className: Pagination_default.list__item, children: item !== "truncator" ? /* @__PURE__ */ (0, import_jsx_runtime241.jsx)(
         Button,
@@ -8106,7 +9399,7 @@ var Pagination = (0, import_react81.forwardRef)(
           icon: MoreHorizontalIcon,
           className: Pagination_default["truncation-icon"]
         }
-      ) }, `pagination-item-${i}`);
+      ) }, `pagination-item-${i2}`);
     }) : void 0;
     const previousPageButton = /* @__PURE__ */ (0, import_jsx_runtime241.jsx)(
       Button,
@@ -8292,7 +9585,7 @@ Pagination.displayName = "Pagination";
 
 // src/components/Popover/Popover.tsx
 var import_dds_design_tokens17 = require("@norges-domstoler/dds-design-tokens");
-var import_react82 = require("react");
+var import_react83 = require("react");
 
 // src/components/Popover/Popover.module.css
 var Popover_default = {
@@ -8304,7 +9597,7 @@ var Popover_default = {
 
 // src/components/Popover/Popover.tsx
 var import_jsx_runtime242 = require("react/jsx-runtime");
-var Popover = (0, import_react82.forwardRef)(
+var Popover = (0, import_react83.forwardRef)(
   (props, ref) => {
     const {
       title,
@@ -8388,7 +9681,7 @@ var Popover = (0, import_react82.forwardRef)(
 Popover.displayName = "Popover";
 
 // src/components/Popover/PopoverGroup.tsx
-var import_react83 = require("react");
+var import_react84 = require("react");
 var import_jsx_runtime243 = require("react/jsx-runtime");
 var PopoverGroup = ({
   isOpen = false,
@@ -8397,8 +9690,8 @@ var PopoverGroup = ({
   children,
   popoverId
 }) => {
-  const [open, setOpen] = (0, import_react83.useState)(isOpen);
-  const generatedId = (0, import_react83.useId)();
+  const [open, setOpen] = (0, import_react84.useState)(isOpen);
+  const generatedId = (0, import_react84.useId)();
   const uniquePopoverId = popoverId != null ? popoverId : `${generatedId}-popover`;
   const handleOnCloseButtonClick = () => {
     setOpen(false);
@@ -8408,8 +9701,8 @@ var PopoverGroup = ({
     setOpen(!open);
     onTriggerClick && onTriggerClick();
   };
-  const buttonRef = (0, import_react83.useRef)(null);
-  const popoverRef = (0, import_react83.useRef)(null);
+  const buttonRef = (0, import_react84.useRef)(null);
+  const popoverRef = (0, import_react84.useRef)(null);
   useOnKeyDown(["Esc", "Escape"], () => {
     var _a;
     if (open) {
@@ -8418,14 +9711,14 @@ var PopoverGroup = ({
     }
   });
   const handleClose = () => setOpen(false);
-  const Children8 = import_react83.Children.map(children, (child, childIndex) => {
-    return (0, import_react83.isValidElement)(child) && (childIndex === 0 ? (0, import_react83.cloneElement)(child, {
+  const Children8 = import_react84.Children.map(children, (child, childIndex) => {
+    return (0, import_react84.isValidElement)(child) && (childIndex === 0 ? (0, import_react84.cloneElement)(child, {
       "aria-haspopup": "dialog",
       "aria-controls": uniquePopoverId,
       "aria-expanded": open,
       onClick: handleOnTriggerClick,
       ref: buttonRef
-    }) : (0, import_react83.cloneElement)(child, {
+    }) : (0, import_react84.cloneElement)(child, {
       isOpen: open,
       "aria-hidden": !open,
       id: uniquePopoverId,
@@ -8440,16 +9733,16 @@ var PopoverGroup = ({
 PopoverGroup.displayName = "PopoverGroup";
 
 // src/components/ProgressTracker/ProgressTracker.tsx
-var import_react86 = require("react");
+var import_react87 = require("react");
 
 // src/components/ProgressTracker/ProgressTracker.context.tsx
-var import_react84 = require("react");
-var ProgressTrackerContext = (0, import_react84.createContext)(
+var import_react85 = require("react");
+var ProgressTrackerContext = (0, import_react85.createContext)(
   {
     activeStep: 0
   }
 );
-var useProgressTrackerContext = () => (0, import_react84.useContext)(ProgressTrackerContext);
+var useProgressTrackerContext = () => (0, import_react85.useContext)(ProgressTrackerContext);
 
 // src/components/ProgressTracker/ProgressTracker.module.css
 var ProgressTracker_default = {
@@ -8473,7 +9766,7 @@ var ProgressTracker_default = {
 };
 
 // src/components/ProgressTracker/ProgressTrackerItem.tsx
-var import_react85 = require("react");
+var import_react86 = require("react");
 var import_jsx_runtime244 = require("react/jsx-runtime");
 var toItemState = (active, completed, disabled) => {
   if (disabled) {
@@ -8504,7 +9797,7 @@ var ProgressTrackerItem = (props) => {
   const { activeStep, handleStepChange } = useProgressTrackerContext();
   const active = activeStep === index;
   const itemState = toItemState(active, completed, disabled);
-  const stepNumberContent = (0, import_react85.useMemo)(() => {
+  const stepNumberContent = (0, import_react86.useMemo)(() => {
     if (completed) {
       return /* @__PURE__ */ (0, import_jsx_runtime244.jsx)(Icon, { icon: CheckIcon, iconSize: "small" });
     }
@@ -8556,7 +9849,7 @@ ProgressTrackerItem.displayName = "ProgressTracker.Item";
 // src/components/ProgressTracker/ProgressTracker.tsx
 var import_jsx_runtime245 = require("react/jsx-runtime");
 var ProgressTracker = (() => {
-  const Res = (0, import_react86.forwardRef)((props, ref) => {
+  const Res = (0, import_react87.forwardRef)((props, ref) => {
     const {
       id,
       activeStep = 0,
@@ -8566,12 +9859,12 @@ var ProgressTracker = (() => {
       htmlProps,
       ...rest
     } = props;
-    const [thisActiveStep, setActiveStep] = (0, import_react86.useState)(activeStep);
+    const [thisActiveStep, setActiveStep] = (0, import_react87.useState)(activeStep);
     const handleChange = (step) => {
       setActiveStep(step);
       onStepChange && onStepChange(step);
     };
-    (0, import_react86.useEffect)(() => {
+    (0, import_react87.useEffect)(() => {
       if (activeStep !== void 0 && activeStep != thisActiveStep) {
         setActiveStep(activeStep);
       }
@@ -8580,7 +9873,7 @@ var ProgressTracker = (() => {
       ...getBaseHTMLProps(id, className, htmlProps, rest),
       ref
     };
-    const steps = (0, import_react86.useMemo)(() => {
+    const steps = (0, import_react87.useMemo)(() => {
       const validChildren = removeInvalidChildren(children);
       const itemsWithIndex = passIndexPropToProgressTrackerItem(validChildren);
       const itemsWithConnectorsBetween = intersperseItemsWithConnector(itemsWithIndex);
@@ -8602,35 +9895,35 @@ var ProgressTracker = (() => {
   return Res;
 })();
 function removeInvalidChildren(children) {
-  return import_react86.Children.toArray(children).filter(import_react86.isValidElement);
+  return import_react87.Children.toArray(children).filter(import_react87.isValidElement);
 }
 function passIndexPropToProgressTrackerItem(children) {
-  return import_react86.Children.map(
+  return import_react87.Children.map(
     children,
-    (item, index) => (0, import_react86.cloneElement)(item, {
+    (item, index) => (0, import_react87.cloneElement)(item, {
       ...item.props,
       index
     })
   );
 }
-var intersperseItemsWithConnector = (children) => import_react86.Children.map(children, (child, index) => {
+var intersperseItemsWithConnector = (children) => import_react87.Children.map(children, (child, index) => {
   if (index === 0) {
     return child;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime245.jsxs)(import_react86.Fragment, { children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime245.jsxs)(import_react87.Fragment, { children: [
     /* @__PURE__ */ (0, import_jsx_runtime245.jsx)("div", { "aria-hidden": true, className: ProgressTracker_default.connector }),
     child
   ] }, index);
 });
 
 // src/components/Search/Search.tsx
-var import_react89 = require("react");
+var import_react90 = require("react");
 
 // src/components/Search/AutocompleteSearch.context.tsx
-var import_react87 = require("react");
-var AutocompleteSearchContext = (0, import_react87.createContext)({});
+var import_react88 = require("react");
+var AutocompleteSearchContext = (0, import_react88.createContext)({});
 var useAutocompleteSearch = () => {
-  return (0, import_react87.useContext)(AutocompleteSearchContext);
+  return (0, import_react88.useContext)(AutocompleteSearchContext);
 };
 
 // src/components/Search/Search.module.css
@@ -8680,9 +9973,9 @@ function createEmptyChangeEvent(inputElementId) {
 }
 
 // src/components/Search/SearchSuggestions.tsx
-var import_react88 = require("react");
+var import_react89 = require("react");
 var import_jsx_runtime246 = require("react/jsx-runtime");
-var SearchSuggestions = (0, import_react88.forwardRef)((props, ref) => {
+var SearchSuggestions = (0, import_react89.forwardRef)((props, ref) => {
   const {
     id,
     searchId,
@@ -8773,7 +10066,7 @@ var getIconSize = (size2) => {
       return "small";
   }
 };
-var Search = (0, import_react89.forwardRef)(
+var Search = (0, import_react90.forwardRef)(
   ({
     componentSize = "medium",
     buttonProps,
@@ -8789,7 +10082,7 @@ var Search = (0, import_react89.forwardRef)(
     ...rest
   }, ref) => {
     var _a;
-    const generatedId = (0, import_react89.useId)();
+    const generatedId = (0, import_react90.useId)();
     const uniqueId = id != null ? id : `${generatedId}-searchInput`;
     const hasLabel = !!label;
     const tipId = derivativeIdGenerator(uniqueId, "tip");
@@ -8798,7 +10091,7 @@ var Search = (0, import_react89.forwardRef)(
       uniqueId,
       "suggestions-description"
     );
-    const [hasValue, setHasValue] = (0, import_react89.useState)(!!value);
+    const [hasValue, setHasValue] = (0, import_react90.useState)(!!value);
     const context = useAutocompleteSearch();
     const combinedRef = context.inputRef ? useCombinedRef(context.inputRef, ref) : ref;
     const handleChange = (e) => {
@@ -8913,24 +10206,24 @@ var Search = (0, import_react89.forwardRef)(
 Search.displayName = "Search";
 
 // src/components/Search/SearchAutocompleteWrapper.tsx
-var import_react90 = require("react");
+var import_react91 = require("react");
 var import_jsx_runtime248 = require("react/jsx-runtime");
 var SearchAutocompleteWrapper = (props) => {
   const {
     value,
     data,
-    filter,
+    filter: filter2,
     queryLength = 2,
     onChange,
     onSuggestionSelection,
     children
   } = props;
-  const [inputValue, setInputValue] = (0, import_react90.useState)(value != null ? value : "");
-  const [suggestions, setSuggestions] = (0, import_react90.useState)([]);
-  const [showSuggestions, setShowSuggestions] = (0, import_react90.useState)(false);
+  const [inputValue, setInputValue] = (0, import_react91.useState)(value != null ? value : "");
+  const [suggestions, setSuggestions] = (0, import_react91.useState)([]);
+  const [showSuggestions, setShowSuggestions] = (0, import_react91.useState)(false);
   const closeSuggestions = () => showSuggestions === true && setShowSuggestions(false);
   const openSuggestions = () => showSuggestions === false && setShowSuggestions(true);
-  (0, import_react90.useEffect)(() => {
+  (0, import_react91.useEffect)(() => {
     if (suggestions.length > 0) {
       openSuggestions();
     } else {
@@ -8947,16 +10240,16 @@ var SearchAutocompleteWrapper = (props) => {
         if (isWeightedValueData(data)) {
           const { sortFunction, array } = data;
           const filteredSuggestions = array.filter(
-            (suggestion) => filter ? filter(suggestion.text, query) : searchFilter(suggestion.text, query)
+            (suggestion) => filter2 ? filter2(suggestion.text, query) : searchFilter(suggestion.text, query)
           );
-          finalSuggestions = filteredSuggestions.sort(sortFunction ? (a2, b) => sortFunction(a2, b) : void 0).map((item) => item.text);
+          finalSuggestions = filteredSuggestions.sort(sortFunction ? (a3, b) => sortFunction(a3, b) : void 0).map((item) => item.text);
         } else {
           const { sortFunction, array } = data;
           const filteredSuggestions = array.filter(
-            (suggestion) => filter ? filter(suggestion, query) : searchFilter(suggestion, query)
+            (suggestion) => filter2 ? filter2(suggestion, query) : searchFilter(suggestion, query)
           );
           finalSuggestions = filteredSuggestions.sort(
-            sortFunction ? (a2, b) => sortFunction(a2, b) : void 0
+            sortFunction ? (a3, b) => sortFunction(a3, b) : void 0
           );
         }
       }
@@ -8975,8 +10268,8 @@ var SearchAutocompleteWrapper = (props) => {
   const handleSetInputValue = (value2) => {
     setInputValue(value2 != null ? value2 : "");
   };
-  const inputRef = (0, import_react90.useRef)(null);
-  const suggestionsRef = (0, import_react90.useRef)(null);
+  const inputRef = (0, import_react91.useRef)(null);
+  const suggestionsRef = (0, import_react91.useRef)(null);
   useOnClickOutside([inputRef.current, suggestionsRef.current], () => {
     closeSuggestions();
   });
@@ -9000,17 +10293,17 @@ Search2.AutocompleteWrapper = SearchAutocompleteWrapper;
 Search2.Suggestions = SearchSuggestions;
 
 // src/components/SelectionControl/Checkbox/Checkbox.tsx
-var import_react93 = require("react");
+var import_react94 = require("react");
 
 // src/components/SelectionControl/Checkbox/CheckboxGroupContext.tsx
-var import_react91 = require("react");
-var CheckboxGroupContext = (0, import_react91.createContext)(null);
+var import_react92 = require("react");
+var CheckboxGroupContext = (0, import_react92.createContext)(null);
 var useCheckboxGroup = () => {
-  return (0, import_react91.useContext)(CheckboxGroupContext);
+  return (0, import_react92.useContext)(CheckboxGroupContext);
 };
 
 // src/components/SelectionControl/SelectionControl.styles.tsx
-var import_react92 = require("react");
+var import_react93 = require("react");
 
 // src/components/SelectionControl/SelectionControl.module.css
 var SelectionControl_default = {
@@ -9031,7 +10324,7 @@ var SelectionControl_default = {
 
 // src/components/SelectionControl/SelectionControl.styles.tsx
 var import_jsx_runtime249 = require("react/jsx-runtime");
-var SelectionControl = (0, import_react92.forwardRef)((props, ref) => {
+var SelectionControl = (0, import_react93.forwardRef)((props, ref) => {
   const { controlType, className, ...rest } = props;
   return /* @__PURE__ */ (0, import_jsx_runtime249.jsx)(
     "span",
@@ -9046,7 +10339,7 @@ var SelectionControl = (0, import_react92.forwardRef)((props, ref) => {
     }
   );
 });
-var Label2 = (0, import_react92.forwardRef)(
+var Label2 = (0, import_react93.forwardRef)(
   (props, ref) => {
     const {
       disabled,
@@ -9089,7 +10382,7 @@ var selectionControlTypographyProps = {
 
 // src/components/SelectionControl/Checkbox/Checkbox.tsx
 var import_jsx_runtime250 = require("react/jsx-runtime");
-var Checkbox = (0, import_react93.forwardRef)(
+var Checkbox = (0, import_react94.forwardRef)(
   (props, ref) => {
     const {
       id,
@@ -9104,7 +10397,7 @@ var Checkbox = (0, import_react93.forwardRef)(
       htmlProps = {},
       ...rest
     } = props;
-    const generatedId = (0, import_react93.useId)();
+    const generatedId = (0, import_react94.useId)();
     const uniqueId = id != null ? id : `${generatedId}-checkbox`;
     const checkboxGroup = useCheckboxGroup();
     const hasLabel = !!label;
@@ -9165,7 +10458,7 @@ var Checkbox = (0, import_react93.forwardRef)(
 Checkbox.displayName = "Checkbox";
 
 // src/components/SelectionControl/Checkbox/CheckboxGroup.tsx
-var import_react94 = require("react");
+var import_react95 = require("react");
 var import_jsx_runtime251 = require("react/jsx-runtime");
 var CheckboxGroup = (props) => {
   const {
@@ -9184,7 +10477,7 @@ var CheckboxGroup = (props) => {
     ...rest
   } = props;
   const { "aria-required": ariaRequired } = htmlProps;
-  const generatedId = (0, import_react94.useId)();
+  const generatedId = (0, import_react95.useId)();
   const uniqueGroupId = groupId != null ? groupId : `${generatedId}-checkboxGroup`;
   const hasErrorMessage = !!errorMessage;
   const showRequiredMarker = required || ariaRequired;
@@ -9240,13 +10533,13 @@ var CheckboxGroup = (props) => {
 CheckboxGroup.displayName = "CheckboxGroup";
 
 // src/components/SelectionControl/RadioButton/RadioButton.tsx
-var import_react96 = require("react");
+var import_react97 = require("react");
 
 // src/components/SelectionControl/RadioButton/RadioButtonGroupContext.tsx
-var import_react95 = require("react");
-var RadioButtonGroupContext = (0, import_react95.createContext)(null);
+var import_react96 = require("react");
+var RadioButtonGroupContext = (0, import_react96.createContext)(null);
 var useRadioButtonGroup = () => {
-  return (0, import_react95.useContext)(RadioButtonGroupContext);
+  return (0, import_react96.useContext)(RadioButtonGroupContext);
 };
 
 // src/components/SelectionControl/RadioButton/RadioButton.tsx
@@ -9260,7 +10553,7 @@ var isValueEqualToGroupValueOrFalsy = (value, group) => {
   }
   return !!value;
 };
-var RadioButton = (0, import_react96.forwardRef)(
+var RadioButton = (0, import_react97.forwardRef)(
   (props, ref) => {
     const {
       id,
@@ -9284,7 +10577,7 @@ var RadioButton = (0, import_react96.forwardRef)(
       style,
       ...restHtmlProps
     } = htmlProps;
-    const generatedId = (0, import_react96.useId)();
+    const generatedId = (0, import_react97.useId)();
     const uniqueId = id != null ? id : `${generatedId}-radioButton`;
     const hasLabel = !!label;
     const radioButtonGroup = useRadioButtonGroup();
@@ -9344,7 +10637,7 @@ var RadioButton = (0, import_react96.forwardRef)(
 RadioButton.displayName = "RadioButton";
 
 // src/components/SelectionControl/RadioButton/RadioButtonGroup.tsx
-var import_react97 = require("react");
+var import_react98 = require("react");
 var import_jsx_runtime253 = require("react/jsx-runtime");
 var RadioButtonGroupInner = (props, ref) => {
   const {
@@ -9366,8 +10659,8 @@ var RadioButtonGroupInner = (props, ref) => {
     ...rest
   } = props;
   const { "aria-required": ariaRequired = false } = htmlProps;
-  const [groupValue, setGroupValue] = (0, import_react97.useState)(value);
-  const generatedId = (0, import_react97.useId)();
+  const [groupValue, setGroupValue] = (0, import_react98.useState)(value);
+  const generatedId = (0, import_react98.useId)();
   const uniqueGroupId = groupId != null ? groupId : `${generatedId}-radioButtonGroup`;
   const handleChange = combineHandlers(
     (e) => setGroupValue(e.target.value),
@@ -9428,11 +10721,11 @@ var RadioButtonGroupInner = (props, ref) => {
     }
   );
 };
-var RadioButtonGroup = (0, import_react97.forwardRef)(RadioButtonGroupInner);
+var RadioButtonGroup = (0, import_react98.forwardRef)(RadioButtonGroupInner);
 RadioButtonGroup.displayName = "RadioButtonGroup";
 
 // src/components/SkipToContent/SkipToContent.tsx
-var import_react98 = require("react");
+var import_react99 = require("react");
 
 // src/components/SkipToContent/SkipToContent.module.css
 var SkipToContent_default = {
@@ -9442,7 +10735,7 @@ var SkipToContent_default = {
 
 // src/components/SkipToContent/SkipToContent.tsx
 var import_jsx_runtime254 = require("react/jsx-runtime");
-var SkipToContent = (0, import_react98.forwardRef)(
+var SkipToContent = (0, import_react99.forwardRef)(
   (props, ref) => {
     const {
       text = "Til hovedinnhold",
@@ -9479,7 +10772,7 @@ var SkipToContent = (0, import_react98.forwardRef)(
 SkipToContent.displayName = "SkipToContent";
 
 // src/components/SplitButton/SplitButton.tsx
-var import_react99 = require("react");
+var import_react100 = require("react");
 
 // src/components/SplitButton/SplitButton.module.css
 var SplitButton_default = {
@@ -9491,7 +10784,7 @@ var SplitButton_default = {
 
 // src/components/SplitButton/SplitButton.tsx
 var import_jsx_runtime255 = require("react/jsx-runtime");
-var SplitButton = (0, import_react99.forwardRef)(
+var SplitButton = (0, import_react100.forwardRef)(
   (props, ref) => {
     const {
       size: size2,
@@ -9501,7 +10794,7 @@ var SplitButton = (0, import_react99.forwardRef)(
       className,
       ...rest
     } = props;
-    const [isOpen, setIsOpen] = (0, import_react99.useState)(false);
+    const [isOpen, setIsOpen] = (0, import_react100.useState)(false);
     const buttonStyleProps = {
       purpose,
       size: size2
@@ -9538,20 +10831,20 @@ var SplitButton = (0, import_react99.forwardRef)(
 SplitButton.displayName = "SplitButton";
 
 // src/components/Table/collapsible/CollapsibleRow.tsx
-var import_react109 = require("react");
+var import_react110 = require("react");
 
 // src/components/Table/collapsible/Table.context.tsx
-var import_react100 = require("react");
-var CollapsibleTableContext = (0, import_react100.createContext)({
+var import_react101 = require("react");
+var CollapsibleTableContext = (0, import_react101.createContext)({
   headerValues: [],
   definingColumnIndex: [0]
 });
-var useCollapsibleTableContext = () => (0, import_react100.useContext)(CollapsibleTableContext);
+var useCollapsibleTableContext = () => (0, import_react101.useContext)(CollapsibleTableContext);
 
 // src/components/Table/normal/Body.tsx
-var import_react101 = require("react");
+var import_react102 = require("react");
 var import_jsx_runtime256 = require("react/jsx-runtime");
-var Body = (0, import_react101.forwardRef)(
+var Body = (0, import_react102.forwardRef)(
   (props, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime256.jsx)("tbody", { ref, ...props });
   }
@@ -9559,20 +10852,20 @@ var Body = (0, import_react101.forwardRef)(
 Body.displayName = "Table.Body";
 
 // src/components/Table/normal/Cell.tsx
-var import_react103 = require("react");
+var import_react104 = require("react");
 
 // src/components/Table/normal/Head.tsx
-var import_react102 = require("react");
+var import_react103 = require("react");
 var import_jsx_runtime257 = require("react/jsx-runtime");
-var Head = (0, import_react102.forwardRef)(
+var Head = (0, import_react103.forwardRef)(
   ({ children, ...rest }, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime257.jsx)("thead", { ref, ...rest, children: /* @__PURE__ */ (0, import_jsx_runtime257.jsx)(HeadContext.Provider, { value: true, children }) });
   }
 );
 Head.displayName = "Table.Head";
-var HeadContext = (0, import_react102.createContext)(false);
+var HeadContext = (0, import_react103.createContext)(false);
 function useIsInTableHead() {
-  const isInTableHead = (0, import_react102.useContext)(HeadContext);
+  const isInTableHead = (0, import_react103.useContext)(HeadContext);
   return isInTableHead;
 }
 
@@ -9603,7 +10896,7 @@ var Table_default = {
 
 // src/components/Table/normal/Cell.tsx
 var import_jsx_runtime258 = require("react/jsx-runtime");
-var Cell = (0, import_react103.forwardRef)(
+var Cell = (0, import_react104.forwardRef)(
   ({
     children,
     type: _type,
@@ -9642,9 +10935,9 @@ var Cell = (0, import_react103.forwardRef)(
 Cell.displayName = "Table.Cell";
 
 // src/components/Table/normal/Foot.tsx
-var import_react104 = require("react");
+var import_react105 = require("react");
 var import_jsx_runtime259 = require("react/jsx-runtime");
-var Foot = (0, import_react104.forwardRef)(
+var Foot = (0, import_react105.forwardRef)(
   (props, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime259.jsx)("tfoot", { ref, ...props });
   }
@@ -9652,9 +10945,9 @@ var Foot = (0, import_react104.forwardRef)(
 Foot.displayName = "Table.Foot";
 
 // src/components/Table/normal/Row.tsx
-var import_react105 = require("react");
+var import_react106 = require("react");
 var import_jsx_runtime260 = require("react/jsx-runtime");
-var Row = (0, import_react105.forwardRef)(
+var Row = (0, import_react106.forwardRef)(
   ({ type: _type, mode = "normal", hoverable, selected, className, ...rest }, ref) => {
     const isInHeader = useIsInTableHead();
     const type = _type != null ? _type : isInHeader ? "head" : "body";
@@ -9681,7 +10974,7 @@ var Row = (0, import_react105.forwardRef)(
 Row.displayName = "Table.Row";
 
 // src/components/Table/normal/SortCell.tsx
-var import_react106 = require("react");
+var import_react107 = require("react");
 var import_jsx_runtime261 = require("react/jsx-runtime");
 var makeSortIcon = (isSorted, sortOrder) => {
   if (!isSorted || !sortOrder) {
@@ -9689,7 +10982,7 @@ var makeSortIcon = (isSorted, sortOrder) => {
   }
   return sortOrder === "ascending" ? /* @__PURE__ */ (0, import_jsx_runtime261.jsx)(Icon, { icon: ChevronDownIcon, iconSize: "inherit" }) : /* @__PURE__ */ (0, import_jsx_runtime261.jsx)(Icon, { icon: ChevronUpIcon, iconSize: "inherit" });
 };
-var SortCell = (0, import_react106.forwardRef)(
+var SortCell = (0, import_react107.forwardRef)(
   ({ isSorted, sortOrder, onClick, children, ...rest }, ref) => /* @__PURE__ */ (0, import_jsx_runtime261.jsx)(
     Cell,
     {
@@ -9721,7 +11014,7 @@ var SortCell = (0, import_react106.forwardRef)(
 SortCell.displayName = "Table.SortCell";
 
 // src/components/Table/normal/Table.tsx
-var import_react107 = require("react");
+var import_react108 = require("react");
 var import_jsx_runtime262 = require("react/jsx-runtime");
 function getDensityCn(value) {
   switch (value) {
@@ -9732,7 +11025,7 @@ function getDensityCn(value) {
       return "extra-compact";
   }
 }
-var Table = (0, import_react107.forwardRef)(
+var Table = (0, import_react108.forwardRef)(
   ({
     density = "normal",
     stickyHeader,
@@ -9762,23 +11055,23 @@ var Table = (0, import_react107.forwardRef)(
 Table.displayName = "Table";
 
 // src/components/Table/normal/TableWrapper.tsx
-var import_react108 = require("react");
+var import_react109 = require("react");
 var import_jsx_runtime263 = require("react/jsx-runtime");
 var TableWrapper = ({ className, ...rest }) => {
-  const [overflowX, setOverflowX] = (0, import_react108.useState)(false);
-  const [windowWidth, setWindowWidth] = (0, import_react108.useState)(window.innerWidth);
+  const [overflowX, setOverflowX] = (0, import_react109.useState)(false);
+  const [windowWidth, setWindowWidth] = (0, import_react109.useState)(window.innerWidth);
   function isOverflowingX(event) {
     return event.offsetWidth < event.scrollWidth;
   }
-  const wrapperRef = (0, import_react108.useRef)(null);
-  (0, import_react108.useEffect)(() => {
+  const wrapperRef = (0, import_react109.useRef)(null);
+  (0, import_react109.useEffect)(() => {
     if ((wrapperRef == null ? void 0 : wrapperRef.current) && isOverflowingX(wrapperRef.current)) {
       setOverflowX(true);
       return;
     }
     setOverflowX(false);
   }, [windowWidth]);
-  (0, import_react108.useEffect)(() => {
+  (0, import_react109.useEffect)(() => {
     function handleResize() {
       setWindowWidth(window.innerWidth);
     }
@@ -9813,7 +11106,7 @@ Table2.Foot = Foot;
 
 // src/components/Table/collapsible/CollapsibleRow.tsx
 var import_jsx_runtime264 = require("react/jsx-runtime");
-var CollapsibleRow = (0, import_react109.forwardRef)(
+var CollapsibleRow = (0, import_react110.forwardRef)(
   ({
     type: _type,
     className,
@@ -9826,8 +11119,8 @@ var CollapsibleRow = (0, import_react109.forwardRef)(
     const isInHead = useIsInTableHead();
     const type = _type != null ? _type : isInHead ? "head" : "body";
     const { isCollapsed, headerValues, definingColumnIndex } = useCollapsibleTableContext();
-    const [childrenCollapsed, setChildrenCollapsed] = (0, import_react109.useState)(true);
-    (0, import_react109.useEffect)(() => {
+    const [childrenCollapsed, setChildrenCollapsed] = (0, import_react110.useState)(true);
+    (0, import_react110.useEffect)(() => {
       !isCollapsed && setChildrenCollapsed(true);
     }, [isCollapsed]);
     const rowProps = (isOpenCollapsibleHeader) => {
@@ -9843,27 +11136,27 @@ var CollapsibleRow = (0, import_react109.forwardRef)(
       };
     };
     const collapsedHeaderValues = headerValues.filter(
-      (column, index) => definingColumnIndex.indexOf(index) === -1
+      (column2, index) => definingColumnIndex.indexOf(index) === -1
     );
-    const childrenArray = import_react109.Children.toArray(children);
+    const childrenArray = import_react110.Children.toArray(children);
     const collapsedChildren = childrenArray.filter(
-      (column, index) => definingColumnIndex.indexOf(index) === -1
+      (column2, index) => definingColumnIndex.indexOf(index) === -1
     );
-    const prefix2 = "collapsibleRow";
+    const prefix3 = "collapsibleRow";
     const collapsibleIds = [];
     const collapsedRenderedChildren = isCollapsed && collapsedHeaderValues.length > 0 ? collapsedChildren.map(function(child, index) {
-      const id = derivativeIdGenerator(prefix2, index.toString());
+      const id = derivativeIdGenerator(prefix3, index.toString());
       collapsibleIds.push(id);
-      return /* @__PURE__ */ (0, import_jsx_runtime264.jsxs)(import_react109.Fragment, { children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime264.jsxs)(import_react110.Fragment, { children: [
         /* @__PURE__ */ (0, import_jsx_runtime264.jsx)(DescriptionListTerm, { children: collapsedHeaderValues[index].content }),
-        (0, import_react109.isValidElement)(child) && (0, import_react109.cloneElement)(child, {
+        (0, import_react110.isValidElement)(child) && (0, import_react110.cloneElement)(child, {
           collapsibleProps: { isCollapsibleChild: true }
         })
       ] }, `DL-${index}`);
     }) : null;
     const collapsedRows = collapsedRenderedChildren && collapsedRenderedChildren.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime264.jsx)(Row, { ...rowProps(), children: /* @__PURE__ */ (0, import_jsx_runtime264.jsx)(Cell, { colSpan: definingColumnIndex.length + 1, children: /* @__PURE__ */ (0, import_jsx_runtime264.jsx)(DescriptionList, { children: collapsedRenderedChildren }) }) }) : null;
-    const definingColumnCells = childrenArray.slice().filter((column, index) => definingColumnIndex.indexOf(index) > -1).sort((a2, b) => {
-      return definingColumnIndex.indexOf(childrenArray.indexOf(a2)) - definingColumnIndex.indexOf(childrenArray.indexOf(b));
+    const definingColumnCells = childrenArray.slice().filter((column2, index) => definingColumnIndex.indexOf(index) > -1).sort((a3, b) => {
+      return definingColumnIndex.indexOf(childrenArray.indexOf(a3)) - definingColumnIndex.indexOf(childrenArray.indexOf(b));
     });
     const headerRow = () => {
       if (type !== "head" || !isCollapsed) return null;
@@ -9916,9 +11209,9 @@ var CollapsibleRow = (0, import_react109.forwardRef)(
 CollapsibleRow.displayName = "CollapsibleTable.Row";
 
 // src/components/Table/collapsible/CollapsibleTable.tsx
-var import_react110 = require("react");
+var import_react111 = require("react");
 var import_jsx_runtime265 = require("react/jsx-runtime");
-var CollapsibleTable = (0, import_react110.forwardRef)((props, ref) => {
+var CollapsibleTable = (0, import_react111.forwardRef)((props, ref) => {
   const {
     isCollapsed,
     headerValues,
@@ -9944,11 +11237,11 @@ var CollapsibleTable2 = CollapsibleTable;
 CollapsibleTable2.Row = CollapsibleRow;
 
 // src/components/Tabs/Tabs.tsx
-var import_react112 = require("react");
+var import_react113 = require("react");
 
 // src/components/Tabs/Tabs.context.tsx
-var import_react111 = require("react");
-var TabsContext = (0, import_react111.createContext)({
+var import_react112 = require("react");
+var TabsContext = (0, import_react112.createContext)({
   activeTab: 0,
   tabsId: "",
   handleTabChange: () => null,
@@ -9958,7 +11251,7 @@ var TabsContext = (0, import_react111.createContext)({
   setHasTabFocus: () => null,
   tabContentDirection: "row"
 });
-var useTabsContext = () => (0, import_react111.useContext)(TabsContext);
+var useTabsContext = () => (0, import_react112.useContext)(TabsContext);
 
 // src/components/Tabs/Tabs.module.css
 var Tabs_default = {
@@ -9976,7 +11269,7 @@ var Tabs_default = {
 
 // src/components/Tabs/Tabs.tsx
 var import_jsx_runtime266 = require("react/jsx-runtime");
-var Tabs = (0, import_react112.forwardRef)((props, ref) => {
+var Tabs = (0, import_react113.forwardRef)((props, ref) => {
   const {
     id,
     activeTab,
@@ -9988,17 +11281,17 @@ var Tabs = (0, import_react112.forwardRef)((props, ref) => {
     htmlProps,
     ...rest
   } = props;
-  const generatedId = (0, import_react112.useId)();
+  const generatedId = (0, import_react113.useId)();
   const uniqueId = id != null ? id : `${generatedId}-tabs`;
-  const [thisActiveTab, setActiveTab] = (0, import_react112.useState)(activeTab != null ? activeTab : 0);
-  const [hasTabFocus, setHasTabFocus] = (0, import_react112.useState)(false);
-  const tabListRef = (0, import_react112.useRef)(null);
-  const tabPanelsRef = (0, import_react112.useRef)(null);
+  const [thisActiveTab, setActiveTab] = (0, import_react113.useState)(activeTab != null ? activeTab : 0);
+  const [hasTabFocus, setHasTabFocus] = (0, import_react113.useState)(false);
+  const tabListRef = (0, import_react113.useRef)(null);
+  const tabPanelsRef = (0, import_react113.useRef)(null);
   const handleTabChange = (index) => {
     setActiveTab(index);
     onChange && onChange(index);
   };
-  (0, import_react112.useEffect)(() => {
+  (0, import_react113.useEffect)(() => {
     if (activeTab !== void 0 && activeTab !== thisActiveTab) {
       setActiveTab(activeTab);
     }
@@ -10040,12 +11333,12 @@ var Tabs = (0, import_react112.forwardRef)((props, ref) => {
 Tabs.displayName = "Tabs";
 
 // src/components/Tabs/Tab.tsx
-var import_react114 = require("react");
+var import_react115 = require("react");
 
 // src/components/Tabs/TabWidthContext.tsx
-var import_react113 = require("react");
+var import_react114 = require("react");
 var import_jsx_runtime267 = require("react/jsx-runtime");
-var TabContext = (0, import_react113.createContext)(null);
+var TabContext = (0, import_react114.createContext)(null);
 function TabWidthContextProvider({
   children,
   onChangeWidths
@@ -10055,15 +11348,15 @@ function TabWidthContextProvider({
     {
       value: {
         updateWidth: (index, newWidth) => {
-          onChangeWidths((prev) => {
-            const newValue = [...prev];
+          onChangeWidths((prev2) => {
+            const newValue = [...prev2];
             newValue[index] = newWidth;
             return newValue;
           });
         },
         removeTab: (index) => {
-          onChangeWidths((prev) => {
-            const newValue = [...prev];
+          onChangeWidths((prev2) => {
+            const newValue = [...prev2];
             newValue.splice(index, 1);
             return newValue;
           });
@@ -10074,8 +11367,8 @@ function TabWidthContextProvider({
   );
 }
 function useSetTabWidth(index, width) {
-  const context = (0, import_react113.useContext)(TabContext);
-  (0, import_react113.useLayoutEffect)(() => {
+  const context = (0, import_react114.useContext)(TabContext);
+  (0, import_react114.useLayoutEffect)(() => {
     context == null ? void 0 : context.updateWidth(index, width);
     return () => context == null ? void 0 : context.removeTab(index);
   }, [index, width]);
@@ -10083,7 +11376,7 @@ function useSetTabWidth(index, width) {
 
 // src/components/Tabs/Tab.tsx
 var import_jsx_runtime268 = require("react/jsx-runtime");
-var Tab = (0, import_react114.forwardRef)((props, ref) => {
+var Tab = (0, import_react115.forwardRef)((props, ref) => {
   const {
     active = false,
     icon: icon2,
@@ -10100,16 +11393,16 @@ var Tab = (0, import_react114.forwardRef)((props, ref) => {
     ...rest
   } = props;
   useSetTabWidth(index, width);
-  const itemRef = (0, import_react114.useRef)(null);
+  const itemRef = (0, import_react115.useRef)(null);
   const combinedRef = useCombinedRef(ref, itemRef);
   const { tabContentDirection } = useTabsContext();
-  (0, import_react114.useEffect)(() => {
+  (0, import_react115.useEffect)(() => {
     var _a;
     if (focus) {
       (_a = itemRef.current) == null ? void 0 : _a.focus();
     }
   }, [focus]);
-  const handleSelect = (0, import_react114.useCallback)(() => {
+  const handleSelect = (0, import_react115.useCallback)(() => {
     if (setFocus && index) {
       setFocus(index);
     }
@@ -10154,9 +11447,9 @@ var Tab = (0, import_react114.forwardRef)((props, ref) => {
 Tab.displayName = "Tab";
 
 // src/components/Tabs/TabList.tsx
-var import_react115 = require("react");
+var import_react116 = require("react");
 var import_jsx_runtime269 = require("react/jsx-runtime");
-var TabList = (0, import_react115.forwardRef)(
+var TabList = (0, import_react116.forwardRef)(
   ({ children, id, style, onFocus, ...rest }, ref) => {
     const {
       activeTab,
@@ -10167,11 +11460,11 @@ var TabList = (0, import_react115.forwardRef)(
       setHasTabFocus
     } = useTabsContext();
     const uniqueId = id != null ? id : `${tabsId}-tablist`;
-    const childrenArray = import_react115.Children.toArray(children).length;
+    const childrenArray = import_react116.Children.toArray(children).length;
     const [focus, setFocus] = useRoveFocus(childrenArray, hasTabFocus, "row");
     const combinedRef = useCombinedRef(ref, tabListRef);
-    const tabListChildren = import_react115.Children.map(children, (child, index) => {
-      return (0, import_react115.isValidElement)(child) && (0, import_react115.cloneElement)(child, {
+    const tabListChildren = import_react116.Children.map(children, (child, index) => {
+      return (0, import_react116.isValidElement)(child) && (0, import_react116.cloneElement)(child, {
         id: `${tabsId}-tab-${index}`,
         "aria-controls": `${tabsId}-panel-${index}`,
         active: activeTab === index,
@@ -10181,7 +11474,7 @@ var TabList = (0, import_react115.forwardRef)(
         onClick: () => handleTabChange(index)
       });
     });
-    const [widths, setWidths] = (0, import_react115.useState)([]);
+    const [widths, setWidths] = (0, import_react116.useState)([]);
     const handleOnFocus = (event) => {
       setHasTabFocus(true);
       onFocus && onFocus(event);
@@ -10225,9 +11518,9 @@ var TabList = (0, import_react115.forwardRef)(
 TabList.displayName = "TabList";
 
 // src/components/Tabs/TabPanel.tsx
-var import_react116 = require("react");
+var import_react117 = require("react");
 var import_jsx_runtime270 = require("react/jsx-runtime");
-var TabPanel = (0, import_react116.forwardRef)(
+var TabPanel = (0, import_react117.forwardRef)(
   ({ active = false, children, id, className, htmlProps, ...rest }, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime270.jsx)(
       "div",
@@ -10254,15 +11547,15 @@ var TabPanel = (0, import_react116.forwardRef)(
 TabPanel.displayName = "TabPanel";
 
 // src/components/Tabs/TabPanels.tsx
-var import_react117 = require("react");
+var import_react118 = require("react");
 var import_jsx_runtime271 = require("react/jsx-runtime");
-var TabPanels = (0, import_react117.forwardRef)(
+var TabPanels = (0, import_react118.forwardRef)(
   ({ children, ...rest }, ref) => {
     const { activeTab, tabsId, tabPanelsRef } = useTabsContext();
     const combinedRef = useCombinedRef(ref, tabPanelsRef);
-    const panelChildren = import_react117.Children.map(children, (child, index) => {
+    const panelChildren = import_react118.Children.map(children, (child, index) => {
       const active = index === activeTab;
-      return (0, import_react117.isValidElement)(child) && (0, import_react117.cloneElement)(child, {
+      return (0, import_react118.isValidElement)(child) && (0, import_react118.cloneElement)(child, {
         id: `${tabsId}-panel-${index}`,
         "aria-labelledby": `${tabsId}-tab-${index}`,
         active,
@@ -10275,7 +11568,7 @@ var TabPanels = (0, import_react117.forwardRef)(
 TabPanels.displayName = "TabPanels";
 
 // src/components/Tag/Tag.tsx
-var import_react118 = require("react");
+var import_react119 = require("react");
 
 // src/components/Tag/Tag.module.css
 var Tag_default = {
@@ -10312,7 +11605,7 @@ var purposeVariants3 = {
     icon: void 0
   }
 };
-var Tag = (0, import_react118.forwardRef)((props, ref) => {
+var Tag = (0, import_react119.forwardRef)((props, ref) => {
   const {
     text,
     purpose = "default",
@@ -10352,10 +11645,10 @@ Tag.displayName = "Tag";
 
 // src/components/TextInput/TextInput.tsx
 var import_dds_design_tokens18 = require("@norges-domstoler/dds-design-tokens");
-var import_react120 = require("react");
+var import_react121 = require("react");
 
 // src/components/TextInput/CharCounter.tsx
-var import_react119 = require("react");
+var import_react120 = require("react");
 
 // src/components/TextInput/TextInput.module.css
 var TextInput_default = {
@@ -10383,7 +11676,7 @@ var TextInput_default = {
 var import_jsx_runtime273 = require("react/jsx-runtime");
 function CharCounter(props) {
   const { current, max, id, className, htmlProps, ...rest } = props;
-  const generatedId = (0, import_react119.useId)();
+  const generatedId = (0, import_react120.useId)();
   const uniqueId = id != null ? id : `${generatedId}-characterCounter`;
   return /* @__PURE__ */ (0, import_jsx_runtime273.jsxs)(
     Typography,
@@ -10409,7 +11702,7 @@ var CharCounter_default = CharCounter;
 
 // src/components/TextInput/TextInput.tsx
 var import_jsx_runtime274 = require("react/jsx-runtime");
-var TextInput = (0, import_react120.forwardRef)(
+var TextInput = (0, import_react121.forwardRef)(
   ({
     label,
     disabled,
@@ -10431,39 +11724,39 @@ var TextInput = (0, import_react120.forwardRef)(
     "aria-required": ariaRequired,
     "aria-describedby": ariaDescribedby,
     icon: icon2,
-    prefix: prefix2,
+    prefix: prefix3,
     suffix,
     ...rest
   }, ref) => {
-    const [text, setText] = (0, import_react120.useState)(
+    const [text, setText] = (0, import_react121.useState)(
       getDefaultText(value, defaultValue)
     );
-    const prefixRef = (0, import_react120.useRef)(null);
-    const suffixRef = (0, import_react120.useRef)(null);
-    const [prefixLength, setPrefixLength] = (0, import_react120.useState)(0);
-    const [suffixLength, setSuffixLength] = (0, import_react120.useState)(0);
-    (0, import_react120.useLayoutEffect)(() => {
+    const prefixRef = (0, import_react121.useRef)(null);
+    const suffixRef = (0, import_react121.useRef)(null);
+    const [prefixLength, setPrefixLength] = (0, import_react121.useState)(0);
+    const [suffixLength, setSuffixLength] = (0, import_react121.useState)(0);
+    (0, import_react121.useLayoutEffect)(() => {
       if (prefixRef.current) {
         setPrefixLength(prefixRef.current.offsetWidth);
       }
       if (suffixRef.current) {
         setSuffixLength(suffixRef.current.offsetWidth);
       }
-    }, [prefix2, suffix, readOnly]);
+    }, [prefix3, suffix, readOnly]);
     const onChangeHandler = (event) => {
       setText(event.target.value);
       if (onChange) {
         onChange(event);
       }
     };
-    const generatedId = (0, import_react120.useId)();
+    const generatedId = (0, import_react121.useId)();
     const uniqueId = id != null ? id : `${generatedId}-textInput`;
     const hasErrorMessage = !!errorMessage;
     const hasTip = !!tip;
     const hasLabel = !!label;
     const hasMessage = hasErrorMessage || hasTip || !!maxLength;
     const hasIcon = !!icon2;
-    const hasAffix = !!(prefix2 != null ? prefix2 : suffix);
+    const hasAffix = !!(prefix3 != null ? prefix3 : suffix);
     const hasCharCounter = !!maxLength && Number.isInteger(maxLength) && maxLength > 0 && withCharacterCounter;
     const characterCounterId = derivativeIdGenerator(
       uniqueId,
@@ -10520,7 +11813,7 @@ var TextInput = (0, import_react120.forwardRef)(
       ] });
     } else if (hasAffix) {
       extendedInput = /* @__PURE__ */ (0, import_jsx_runtime274.jsxs)("div", { className: TextInput_default["affix-container"], children: [
-        prefix2 && /* @__PURE__ */ (0, import_jsx_runtime274.jsx)(
+        prefix3 && /* @__PURE__ */ (0, import_jsx_runtime274.jsx)(
           "span",
           {
             ref: prefixRef,
@@ -10530,7 +11823,7 @@ var TextInput = (0, import_react120.forwardRef)(
               TextInput_default.prefix,
               readOnly && TextInput_default["prefix--readonly"]
             ),
-            children: prefix2
+            children: prefix3
           }
         ),
         /* @__PURE__ */ (0, import_jsx_runtime274.jsx)(
@@ -10602,14 +11895,14 @@ var TextInput = (0, import_react120.forwardRef)(
 TextInput.displayName = "TextInput";
 
 // src/components/ToggleBar/ToggleBar.tsx
-var import_react122 = require("react");
+var import_react123 = require("react");
 
 // src/components/ToggleBar/ToggleBar.context.tsx
-var import_react121 = require("react");
-var ToggleBarContext = (0, import_react121.createContext)({
+var import_react122 = require("react");
+var ToggleBarContext = (0, import_react122.createContext)({
   size: "medium"
 });
-var useToggleBarContext = () => (0, import_react121.useContext)(ToggleBarContext);
+var useToggleBarContext = () => (0, import_react122.useContext)(ToggleBarContext);
 
 // src/components/ToggleBar/ToggleBar.module.css
 var ToggleBar_default = {
@@ -10643,9 +11936,9 @@ var ToggleBar = (props) => {
     id,
     ...rest
   } = props;
-  const generatedId = (0, import_react122.useId)();
+  const generatedId = (0, import_react123.useId)();
   const uniqueId = id != null ? id : `${generatedId}-ToggleBar`;
-  const [groupValue, setGroupValue] = (0, import_react122.useState)(value);
+  const [groupValue, setGroupValue] = (0, import_react123.useState)(value);
   const handleChange = combineHandlers(
     (e) => setGroupValue(e.target.value),
     (e) => onChange && onChange(e, e.target.value)
@@ -10684,7 +11977,7 @@ var ToggleBar = (props) => {
 ToggleBar.displayName = "ToggleBar";
 
 // src/components/ToggleBar/ToggleRadio.tsx
-var import_react123 = require("react");
+var import_react124 = require("react");
 var import_jsx_runtime276 = require("react/jsx-runtime");
 var typographyTypes5 = {
   large: "bodySans04",
@@ -10702,7 +11995,7 @@ var calculateChecked = (value, group, checked) => {
   }
   return !!value;
 };
-var ToggleRadio = (0, import_react123.forwardRef)(
+var ToggleRadio = (0, import_react124.forwardRef)(
   (props, ref) => {
     const {
       value,
@@ -10718,7 +12011,7 @@ var ToggleRadio = (0, import_react123.forwardRef)(
       id,
       ...rest
     } = props;
-    const generatedId = (0, import_react123.useId)();
+    const generatedId = (0, import_react124.useId)();
     const uniqueId = id != null ? id : `${generatedId}-ToggleRadio`;
     const group = useToggleBarContext();
     const handleChange = (event) => {
@@ -10772,7 +12065,7 @@ var ToggleRadio = (0, import_react123.forwardRef)(
 ToggleRadio.displayName = "ToggleRadio";
 
 // src/components/ToggleButton/ToggleButton.tsx
-var import_react124 = require("react");
+var import_react125 = require("react");
 
 // src/components/ToggleButton/ToggleButton.module.css
 var ToggleButton_default = {
@@ -10786,9 +12079,9 @@ var ToggleButton_default = {
 
 // src/components/ToggleButton/ToggleButton.tsx
 var import_jsx_runtime277 = require("react/jsx-runtime");
-var ToggleButton = (0, import_react124.forwardRef)(
+var ToggleButton = (0, import_react125.forwardRef)(
   ({ id, label, icon: icon2, className, htmlProps, ...rest }, ref) => {
-    const generatedId = (0, import_react124.useId)();
+    const generatedId = (0, import_react125.useId)();
     const uniqueId = id != null ? id : `${generatedId}-toggleButton`;
     return /* @__PURE__ */ (0, import_jsx_runtime277.jsxs)("label", { htmlFor: uniqueId, className: ToggleButton_default.container, children: [
       /* @__PURE__ */ (0, import_jsx_runtime277.jsx)(
@@ -10829,7 +12122,7 @@ var ToggleButton = (0, import_react124.forwardRef)(
 ToggleButton.displayName = "ToggleButton";
 
 // src/components/ToggleButton/ToggleButtonGroup.tsx
-var import_react125 = require("react");
+var import_react126 = require("react");
 var import_jsx_runtime278 = require("react/jsx-runtime");
 var ToggleButtonGroup = (props) => {
   const {
@@ -10842,7 +12135,7 @@ var ToggleButtonGroup = (props) => {
     htmlProps,
     ...rest
   } = props;
-  const generatedId = (0, import_react125.useId)();
+  const generatedId = (0, import_react126.useId)();
   const uniqueLabelId = labelId != null ? labelId : `${generatedId}-ToggleButtonGroupLabel`;
   return /* @__PURE__ */ (0, import_jsx_runtime278.jsxs)(
     "div",