@helpwave/hightide 0.1.22 → 0.1.24

package/dist/index.js

@@ -29,37 +29,2900 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/@swc/helpers/cjs/_interop_require_default.cjs
+var require_interop_require_default = __commonJS({
+  "node_modules/@swc/helpers/cjs/_interop_require_default.cjs"(exports2) {
+    "use strict";
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    exports2._ = _interop_require_default;
+  }
+});
+
+// node_modules/next/dist/shared/lib/utils/warn-once.js
+var require_warn_once = __commonJS({
+  "node_modules/next/dist/shared/lib/utils/warn-once.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "warnOnce", {
+      enumerable: true,
+      get: function() {
+        return warnOnce;
+      }
+    });
+    var warnOnce = (_) => {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      const warnings = /* @__PURE__ */ new Set();
+      warnOnce = (msg) => {
+        if (!warnings.has(msg)) {
+          console.warn(msg);
+        }
+        warnings.add(msg);
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/image-blur-svg.js
+var require_image_blur_svg = __commonJS({
+  "node_modules/next/dist/shared/lib/image-blur-svg.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "getImageBlurSvg", {
+      enumerable: true,
+      get: function() {
+        return getImageBlurSvg;
+      }
+    });
+    function getImageBlurSvg(param) {
+      let { widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit } = param;
+      const std = 20;
+      const svgWidth = blurWidth ? blurWidth * 40 : widthInt;
+      const svgHeight = blurHeight ? blurHeight * 40 : heightInt;
+      const viewBox = svgWidth && svgHeight ? "viewBox='0 0 " + svgWidth + " " + svgHeight + "'" : "";
+      const preserveAspectRatio = viewBox ? "none" : objectFit === "contain" ? "xMidYMid" : objectFit === "cover" ? "xMidYMid slice" : "none";
+      return "%3Csvg xmlns='http://www.w3.org/2000/svg' " + viewBox + "%3E%3Cfilter id='b' color-interpolation-filters='sRGB'%3E%3CfeGaussianBlur stdDeviation='" + std + "'/%3E%3CfeColorMatrix values='1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1' result='s'/%3E%3CfeFlood x='0' y='0' width='100%25' height='100%25'/%3E%3CfeComposite operator='out' in='s'/%3E%3CfeComposite in2='SourceGraphic'/%3E%3CfeGaussianBlur stdDeviation='" + std + "'/%3E%3C/filter%3E%3Cimage width='100%25' height='100%25' x='0' y='0' preserveAspectRatio='" + preserveAspectRatio + "' style='filter: url(%23b);' href='" + blurDataURL + "'/%3E%3C/svg%3E";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/image-config.js
+var require_image_config = __commonJS({
+  "node_modules/next/dist/shared/lib/image-config.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      VALID_LOADERS: function() {
+        return VALID_LOADERS;
+      },
+      imageConfigDefault: function() {
+        return imageConfigDefault;
+      }
+    });
+    var VALID_LOADERS = [
+      "default",
+      "imgix",
+      "cloudinary",
+      "akamai",
+      "custom"
+    ];
+    var imageConfigDefault = {
+      deviceSizes: [
+        640,
+        750,
+        828,
+        1080,
+        1200,
+        1920,
+        2048,
+        3840
+      ],
+      imageSizes: [
+        16,
+        32,
+        48,
+        64,
+        96,
+        128,
+        256,
+        384
+      ],
+      path: "/_next/image",
+      loader: "default",
+      loaderFile: "",
+      domains: [],
+      disableStaticImages: false,
+      minimumCacheTTL: 60,
+      formats: [
+        "image/webp"
+      ],
+      dangerouslyAllowSVG: false,
+      contentSecurityPolicy: "script-src 'none'; frame-src 'none'; sandbox;",
+      contentDispositionType: "attachment",
+      localPatterns: void 0,
+      remotePatterns: [],
+      qualities: void 0,
+      unoptimized: false
+    };
+  }
+});
+
+// node_modules/next/dist/shared/lib/get-img-props.js
+var require_get_img_props = __commonJS({
+  "node_modules/next/dist/shared/lib/get-img-props.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "getImgProps", {
+      enumerable: true,
+      get: function() {
+        return getImgProps;
+      }
+    });
+    var _warnonce = require_warn_once();
+    var _imageblursvg = require_image_blur_svg();
+    var _imageconfig = require_image_config();
+    var VALID_LOADING_VALUES = [
+      "lazy",
+      "eager",
+      void 0
+    ];
+    var INVALID_BACKGROUND_SIZE_VALUES = [
+      "-moz-initial",
+      "fill",
+      "none",
+      "scale-down",
+      void 0
+    ];
+    function isStaticRequire(src) {
+      return src.default !== void 0;
+    }
+    function isStaticImageData(src) {
+      return src.src !== void 0;
+    }
+    function isStaticImport(src) {
+      return !!src && typeof src === "object" && (isStaticRequire(src) || isStaticImageData(src));
+    }
+    var allImgs = /* @__PURE__ */ new Map();
+    var perfObserver;
+    function getInt(x) {
+      if (typeof x === "undefined") {
+        return x;
+      }
+      if (typeof x === "number") {
+        return Number.isFinite(x) ? x : NaN;
+      }
+      if (typeof x === "string" && /^[0-9]+$/.test(x)) {
+        return parseInt(x, 10);
+      }
+      return NaN;
+    }
+    function getWidths(param, width, sizes) {
+      let { deviceSizes, allSizes } = param;
+      if (sizes) {
+        const viewportWidthRe = /(^|\s)(1?\d?\d)vw/g;
+        const percentSizes = [];
+        for (let match; match = viewportWidthRe.exec(sizes); match) {
+          percentSizes.push(parseInt(match[2]));
+        }
+        if (percentSizes.length) {
+          const smallestRatio = Math.min(...percentSizes) * 0.01;
+          return {
+            widths: allSizes.filter((s) => s >= deviceSizes[0] * smallestRatio),
+            kind: "w"
+          };
+        }
+        return {
+          widths: allSizes,
+          kind: "w"
+        };
+      }
+      if (typeof width !== "number") {
+        return {
+          widths: deviceSizes,
+          kind: "w"
+        };
+      }
+      const widths = [
+        ...new Set(
+          // > This means that most OLED screens that say they are 3x resolution,
+          // > are actually 3x in the green color, but only 1.5x in the red and
+          // > blue colors. Showing a 3x resolution image in the app vs a 2x
+          // > resolution image will be visually the same, though the 3x image
+          // > takes significantly more data. Even true 3x resolution screens are
+          // > wasteful as the human eye cannot see that level of detail without
+          // > something like a magnifying glass.
+          // https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/capping-image-fidelity-on-ultra-high-resolution-devices.html
+          [
+            width,
+            width * 2
+            /*, width * 3*/
+          ].map((w) => allSizes.find((p) => p >= w) || allSizes[allSizes.length - 1])
+        )
+      ];
+      return {
+        widths,
+        kind: "x"
+      };
+    }
+    function generateImgAttrs(param) {
+      let { config, src, unoptimized, width, quality, sizes, loader } = param;
+      if (unoptimized) {
+        return {
+          src,
+          srcSet: void 0,
+          sizes: void 0
+        };
+      }
+      const { widths, kind } = getWidths(config, width, sizes);
+      const last = widths.length - 1;
+      return {
+        sizes: !sizes && kind === "w" ? "100vw" : sizes,
+        srcSet: widths.map((w, i) => loader({
+          config,
+          src,
+          quality,
+          width: w
+        }) + " " + (kind === "w" ? w : i + 1) + kind).join(", "),
+        // It's intended to keep `src` the last attribute because React updates
+        // attributes in order. If we keep `src` the first one, Safari will
+        // immediately start to fetch `src`, before `sizes` and `srcSet` are even
+        // updated by React. That causes multiple unnecessary requests if `srcSet`
+        // and `sizes` are defined.
+        // This bug cannot be reproduced in Chrome or Firefox.
+        src: loader({
+          config,
+          src,
+          quality,
+          width: widths[last]
+        })
+      };
+    }
+    function getImgProps(param, _state) {
+      let { src, sizes, unoptimized = false, priority = false, loading, className, quality, width, height, fill = false, style, overrideSrc, onLoad, onLoadingComplete, placeholder = "empty", blurDataURL, fetchPriority, decoding = "async", layout, objectFit, objectPosition, lazyBoundary, lazyRoot, ...rest } = param;
+      const { imgConf, showAltText, blurComplete, defaultLoader } = _state;
+      let config;
+      let c = imgConf || _imageconfig.imageConfigDefault;
+      if ("allSizes" in c) {
+        config = c;
+      } else {
+        var _c_qualities;
+        const allSizes = [
+          ...c.deviceSizes,
+          ...c.imageSizes
+        ].sort((a, b) => a - b);
+        const deviceSizes = c.deviceSizes.sort((a, b) => a - b);
+        const qualities = (_c_qualities = c.qualities) == null ? void 0 : _c_qualities.sort((a, b) => a - b);
+        config = {
+          ...c,
+          allSizes,
+          deviceSizes,
+          qualities
+        };
+      }
+      if (typeof defaultLoader === "undefined") {
+        throw Object.defineProperty(new Error("images.loaderFile detected but the file is missing default export.\nRead more: https://nextjs.org/docs/messages/invalid-images-config"), "__NEXT_ERROR_CODE", {
+          value: "E163",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      let loader = rest.loader || defaultLoader;
+      delete rest.loader;
+      delete rest.srcSet;
+      const isDefaultLoader = "__next_img_default" in loader;
+      if (isDefaultLoader) {
+        if (config.loader === "custom") {
+          throw Object.defineProperty(new Error('Image with src "' + src + '" is missing "loader" prop.\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader'), "__NEXT_ERROR_CODE", {
+            value: "E252",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      } else {
+        const customImageLoader = loader;
+        loader = (obj) => {
+          const { config: _, ...opts } = obj;
+          return customImageLoader(opts);
+        };
+      }
+      if (layout) {
+        if (layout === "fill") {
+          fill = true;
+        }
+        const layoutToStyle = {
+          intrinsic: {
+            maxWidth: "100%",
+            height: "auto"
+          },
+          responsive: {
+            width: "100%",
+            height: "auto"
+          }
+        };
+        const layoutToSizes = {
+          responsive: "100vw",
+          fill: "100vw"
+        };
+        const layoutStyle = layoutToStyle[layout];
+        if (layoutStyle) {
+          style = {
+            ...style,
+            ...layoutStyle
+          };
+        }
+        const layoutSizes = layoutToSizes[layout];
+        if (layoutSizes && !sizes) {
+          sizes = layoutSizes;
+        }
+      }
+      let staticSrc = "";
+      let widthInt = getInt(width);
+      let heightInt = getInt(height);
+      let blurWidth;
+      let blurHeight;
+      if (isStaticImport(src)) {
+        const staticImageData = isStaticRequire(src) ? src.default : src;
+        if (!staticImageData.src) {
+          throw Object.defineProperty(new Error("An object should only be passed to the image component src parameter if it comes from a static image import. It must include src. Received " + JSON.stringify(staticImageData)), "__NEXT_ERROR_CODE", {
+            value: "E460",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (!staticImageData.height || !staticImageData.width) {
+          throw Object.defineProperty(new Error("An object should only be passed to the image component src parameter if it comes from a static image import. It must include height and width. Received " + JSON.stringify(staticImageData)), "__NEXT_ERROR_CODE", {
+            value: "E48",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        blurWidth = staticImageData.blurWidth;
+        blurHeight = staticImageData.blurHeight;
+        blurDataURL = blurDataURL || staticImageData.blurDataURL;
+        staticSrc = staticImageData.src;
+        if (!fill) {
+          if (!widthInt && !heightInt) {
+            widthInt = staticImageData.width;
+            heightInt = staticImageData.height;
+          } else if (widthInt && !heightInt) {
+            const ratio = widthInt / staticImageData.width;
+            heightInt = Math.round(staticImageData.height * ratio);
+          } else if (!widthInt && heightInt) {
+            const ratio = heightInt / staticImageData.height;
+            widthInt = Math.round(staticImageData.width * ratio);
+          }
+        }
+      }
+      src = typeof src === "string" ? src : staticSrc;
+      let isLazy = !priority && (loading === "lazy" || typeof loading === "undefined");
+      if (!src || src.startsWith("data:") || src.startsWith("blob:")) {
+        unoptimized = true;
+        isLazy = false;
+      }
+      if (config.unoptimized) {
+        unoptimized = true;
+      }
+      if (isDefaultLoader && !config.dangerouslyAllowSVG && src.split("?", 1)[0].endsWith(".svg")) {
+        unoptimized = true;
+      }
+      const qualityInt = getInt(quality);
+      if (process.env.NODE_ENV !== "production") {
+        if (config.output === "export" && isDefaultLoader && !unoptimized) {
+          throw Object.defineProperty(new Error("Image Optimization using the default loader is not compatible with `{ output: 'export' }`.\n  Possible solutions:\n    - Remove `{ output: 'export' }` and run \"next start\" to run server mode including the Image Optimization API.\n    - Configure `{ images: { unoptimized: true } }` in `next.config.js` to disable the Image Optimization API.\n  Read more: https://nextjs.org/docs/messages/export-image-api"), "__NEXT_ERROR_CODE", {
+            value: "E500",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (!src) {
+          unoptimized = true;
+        } else {
+          if (fill) {
+            if (width) {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has both "width" and "fill" properties. Only one should be used.'), "__NEXT_ERROR_CODE", {
+                value: "E96",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if (height) {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has both "height" and "fill" properties. Only one should be used.'), "__NEXT_ERROR_CODE", {
+                value: "E115",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if ((style == null ? void 0 : style.position) && style.position !== "absolute") {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has both "fill" and "style.position" properties. Images with "fill" always use position absolute - it cannot be modified.'), "__NEXT_ERROR_CODE", {
+                value: "E216",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if ((style == null ? void 0 : style.width) && style.width !== "100%") {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has both "fill" and "style.width" properties. Images with "fill" always use width 100% - it cannot be modified.'), "__NEXT_ERROR_CODE", {
+                value: "E73",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if ((style == null ? void 0 : style.height) && style.height !== "100%") {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has both "fill" and "style.height" properties. Images with "fill" always use height 100% - it cannot be modified.'), "__NEXT_ERROR_CODE", {
+                value: "E404",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          } else {
+            if (typeof widthInt === "undefined") {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" is missing required "width" property.'), "__NEXT_ERROR_CODE", {
+                value: "E451",
+                enumerable: false,
+                configurable: true
+              });
+            } else if (isNaN(widthInt)) {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has invalid "width" property. Expected a numeric value in pixels but received "' + width + '".'), "__NEXT_ERROR_CODE", {
+                value: "E66",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if (typeof heightInt === "undefined") {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" is missing required "height" property.'), "__NEXT_ERROR_CODE", {
+                value: "E397",
+                enumerable: false,
+                configurable: true
+              });
+            } else if (isNaN(heightInt)) {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" has invalid "height" property. Expected a numeric value in pixels but received "' + height + '".'), "__NEXT_ERROR_CODE", {
+                value: "E444",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if (/^[\x00-\x20]/.test(src)) {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" cannot start with a space or control character. Use src.trimStart() to remove it or encodeURIComponent(src) to keep it.'), "__NEXT_ERROR_CODE", {
+                value: "E176",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if (/[\x00-\x20]$/.test(src)) {
+              throw Object.defineProperty(new Error('Image with src "' + src + '" cannot end with a space or control character. Use src.trimEnd() to remove it or encodeURIComponent(src) to keep it.'), "__NEXT_ERROR_CODE", {
+                value: "E21",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          }
+        }
+        if (!VALID_LOADING_VALUES.includes(loading)) {
+          throw Object.defineProperty(new Error('Image with src "' + src + '" has invalid "loading" property. Provided "' + loading + '" should be one of ' + VALID_LOADING_VALUES.map(String).join(",") + "."), "__NEXT_ERROR_CODE", {
+            value: "E357",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (priority && loading === "lazy") {
+          throw Object.defineProperty(new Error('Image with src "' + src + `" has both "priority" and "loading='lazy'" properties. Only one should be used.`), "__NEXT_ERROR_CODE", {
+            value: "E218",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (placeholder !== "empty" && placeholder !== "blur" && !placeholder.startsWith("data:image/")) {
+          throw Object.defineProperty(new Error('Image with src "' + src + '" has invalid "placeholder" property "' + placeholder + '".'), "__NEXT_ERROR_CODE", {
+            value: "E431",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (placeholder !== "empty") {
+          if (widthInt && heightInt && widthInt * heightInt < 1600) {
+            (0, _warnonce.warnOnce)('Image with src "' + src + '" is smaller than 40x40. Consider removing the "placeholder" property to improve performance.');
+          }
+        }
+        if (placeholder === "blur" && !blurDataURL) {
+          const VALID_BLUR_EXT = [
+            "jpeg",
+            "png",
+            "webp",
+            "avif"
+          ];
+          throw Object.defineProperty(new Error('Image with src "' + src + `" has "placeholder='blur'" property but is missing the "blurDataURL" property.
+        Possible solutions:
+          - Add a "blurDataURL" property, the contents should be a small Data URL to represent the image
+          - Change the "src" property to a static import with one of the supported file types: ` + VALID_BLUR_EXT.join(",") + ' (animated images not supported)\n          - Remove the "placeholder" property, effectively no blur effect\n        Read more: https://nextjs.org/docs/messages/placeholder-blur-data-url'), "__NEXT_ERROR_CODE", {
+            value: "E371",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if ("ref" in rest) {
+          (0, _warnonce.warnOnce)('Image with src "' + src + '" is using unsupported "ref" property. Consider using the "onLoad" property instead.');
+        }
+        if (!unoptimized && !isDefaultLoader) {
+          const urlStr = loader({
+            config,
+            src,
+            width: widthInt || 400,
+            quality: qualityInt || 75
+          });
+          let url;
+          try {
+            url = new URL(urlStr);
+          } catch (err) {
+          }
+          if (urlStr === src || url && url.pathname === src && !url.search) {
+            (0, _warnonce.warnOnce)('Image with src "' + src + '" has a "loader" property that does not implement width. Please implement it or use the "unoptimized" property instead.\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader-width');
+          }
+        }
+        if (onLoadingComplete) {
+          (0, _warnonce.warnOnce)('Image with src "' + src + '" is using deprecated "onLoadingComplete" property. Please use the "onLoad" property instead.');
+        }
+        for (const [legacyKey, legacyValue] of Object.entries({
+          layout,
+          objectFit,
+          objectPosition,
+          lazyBoundary,
+          lazyRoot
+        })) {
+          if (legacyValue) {
+            (0, _warnonce.warnOnce)('Image with src "' + src + '" has legacy prop "' + legacyKey + '". Did you forget to run the codemod?\nRead more: https://nextjs.org/docs/messages/next-image-upgrade-to-13');
+          }
+        }
+        if (typeof window !== "undefined" && !perfObserver && window.PerformanceObserver) {
+          perfObserver = new PerformanceObserver((entryList) => {
+            for (const entry of entryList.getEntries()) {
+              var _entry_element;
+              const imgSrc = (entry == null ? void 0 : (_entry_element = entry.element) == null ? void 0 : _entry_element.src) || "";
+              const lcpImage = allImgs.get(imgSrc);
+              if (lcpImage && !lcpImage.priority && lcpImage.placeholder === "empty" && !lcpImage.src.startsWith("data:") && !lcpImage.src.startsWith("blob:")) {
+                (0, _warnonce.warnOnce)('Image with src "' + lcpImage.src + '" was detected as the Largest Contentful Paint (LCP). Please add the "priority" property if this image is above the fold.\nRead more: https://nextjs.org/docs/api-reference/next/image#priority');
+              }
+            }
+          });
+          try {
+            perfObserver.observe({
+              type: "largest-contentful-paint",
+              buffered: true
+            });
+          } catch (err) {
+            console.error(err);
+          }
+        }
+      }
+      const imgStyle = Object.assign(fill ? {
+        position: "absolute",
+        height: "100%",
+        width: "100%",
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        objectFit,
+        objectPosition
+      } : {}, showAltText ? {} : {
+        color: "transparent"
+      }, style);
+      const backgroundImage = !blurComplete && placeholder !== "empty" ? placeholder === "blur" ? 'url("data:image/svg+xml;charset=utf-8,' + (0, _imageblursvg.getImageBlurSvg)({
+        widthInt,
+        heightInt,
+        blurWidth,
+        blurHeight,
+        blurDataURL: blurDataURL || "",
+        objectFit: imgStyle.objectFit
+      }) + '")' : 'url("' + placeholder + '")' : null;
+      const backgroundSize = !INVALID_BACKGROUND_SIZE_VALUES.includes(imgStyle.objectFit) ? imgStyle.objectFit : imgStyle.objectFit === "fill" ? "100% 100%" : "cover";
+      let placeholderStyle = backgroundImage ? {
+        backgroundSize,
+        backgroundPosition: imgStyle.objectPosition || "50% 50%",
+        backgroundRepeat: "no-repeat",
+        backgroundImage
+      } : {};
+      if (process.env.NODE_ENV === "development") {
+        if (placeholderStyle.backgroundImage && placeholder === "blur" && (blurDataURL == null ? void 0 : blurDataURL.startsWith("/"))) {
+          placeholderStyle.backgroundImage = 'url("' + blurDataURL + '")';
+        }
+      }
+      const imgAttributes = generateImgAttrs({
+        config,
+        src,
+        unoptimized,
+        width: widthInt,
+        quality: qualityInt,
+        sizes,
+        loader
+      });
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof window !== "undefined") {
+          let fullUrl;
+          try {
+            fullUrl = new URL(imgAttributes.src);
+          } catch (e) {
+            fullUrl = new URL(imgAttributes.src, window.location.href);
+          }
+          allImgs.set(fullUrl.href, {
+            src,
+            priority,
+            placeholder
+          });
+        }
+      }
+      const props = {
+        ...rest,
+        loading: isLazy ? "lazy" : loading,
+        fetchPriority,
+        width: widthInt,
+        height: heightInt,
+        decoding,
+        className,
+        style: {
+          ...imgStyle,
+          ...placeholderStyle
+        },
+        sizes: imgAttributes.sizes,
+        srcSet: imgAttributes.srcSet,
+        src: overrideSrc || imgAttributes.src
+      };
+      const meta = {
+        unoptimized,
+        priority,
+        placeholder,
+        fill
+      };
+      return {
+        props,
+        meta
+      };
+    }
+  }
+});
+
 // node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs
 var require_interop_require_wildcard = __commonJS({
   "node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs"(exports2) {
     "use strict";
-    function _getRequireWildcardCache(nodeInterop) {
-      if (typeof WeakMap !== "function") return null;
-      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
-      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
-      return (_getRequireWildcardCache = function(nodeInterop2) {
-        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
-      })(nodeInterop);
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function") return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interop_require_wildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) return obj;
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) return cache.get(obj);
+      var newObj = { __proto__: null };
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+          else newObj[key] = obj[key];
+        }
+      }
+      newObj.default = obj;
+      if (cache) cache.set(obj, newObj);
+      return newObj;
+    }
+    exports2._ = _interop_require_wildcard;
+  }
+});
+
+// node_modules/next/dist/shared/lib/side-effect.js
+var require_side_effect = __commonJS({
+  "node_modules/next/dist/shared/lib/side-effect.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "default", {
+      enumerable: true,
+      get: function() {
+        return SideEffect;
+      }
+    });
+    var _react = require("react");
+    var isServer = typeof window === "undefined";
+    var useClientOnlyLayoutEffect = isServer ? () => {
+    } : _react.useLayoutEffect;
+    var useClientOnlyEffect = isServer ? () => {
+    } : _react.useEffect;
+    function SideEffect(props) {
+      const { headManager, reduceComponentsToState } = props;
+      function emitChange() {
+        if (headManager && headManager.mountedInstances) {
+          const headElements = _react.Children.toArray(Array.from(headManager.mountedInstances).filter(Boolean));
+          headManager.updateHead(reduceComponentsToState(headElements, props));
+        }
+      }
+      if (isServer) {
+        var _headManager_mountedInstances;
+        headManager == null ? void 0 : (_headManager_mountedInstances = headManager.mountedInstances) == null ? void 0 : _headManager_mountedInstances.add(props.children);
+        emitChange();
+      }
+      useClientOnlyLayoutEffect(() => {
+        var _headManager_mountedInstances2;
+        headManager == null ? void 0 : (_headManager_mountedInstances2 = headManager.mountedInstances) == null ? void 0 : _headManager_mountedInstances2.add(props.children);
+        return () => {
+          var _headManager_mountedInstances3;
+          headManager == null ? void 0 : (_headManager_mountedInstances3 = headManager.mountedInstances) == null ? void 0 : _headManager_mountedInstances3.delete(props.children);
+        };
+      });
+      useClientOnlyLayoutEffect(() => {
+        if (headManager) {
+          headManager._pendingUpdate = emitChange;
+        }
+        return () => {
+          if (headManager) {
+            headManager._pendingUpdate = emitChange;
+          }
+        };
+      });
+      useClientOnlyEffect(() => {
+        if (headManager && headManager._pendingUpdate) {
+          headManager._pendingUpdate();
+          headManager._pendingUpdate = null;
+        }
+        return () => {
+          if (headManager && headManager._pendingUpdate) {
+            headManager._pendingUpdate();
+            headManager._pendingUpdate = null;
+          }
+        };
+      });
+      return null;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/amp-context.shared-runtime.js
+var require_amp_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/amp-context.shared-runtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "AmpStateContext", {
+      enumerable: true,
+      get: function() {
+        return AmpStateContext;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _react = /* @__PURE__ */ _interop_require_default._(require("react"));
+    var AmpStateContext = _react.default.createContext({});
+    if (process.env.NODE_ENV !== "production") {
+      AmpStateContext.displayName = "AmpStateContext";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js
+var require_head_manager_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "HeadManagerContext", {
+      enumerable: true,
+      get: function() {
+        return HeadManagerContext;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _react = /* @__PURE__ */ _interop_require_default._(require("react"));
+    var HeadManagerContext = _react.default.createContext({});
+    if (process.env.NODE_ENV !== "production") {
+      HeadManagerContext.displayName = "HeadManagerContext";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/amp-mode.js
+var require_amp_mode = __commonJS({
+  "node_modules/next/dist/shared/lib/amp-mode.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "isInAmpMode", {
+      enumerable: true,
+      get: function() {
+        return isInAmpMode;
+      }
+    });
+    function isInAmpMode(param) {
+      let { ampFirst = false, hybrid = false, hasQuery = false } = param === void 0 ? {} : param;
+      return ampFirst || hybrid && hasQuery;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/head.js
+var require_head = __commonJS({
+  "node_modules/next/dist/shared/lib/head.js"(exports2, module2) {
+    "use client";
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      default: function() {
+        return _default;
+      },
+      defaultHead: function() {
+        return defaultHead;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _interop_require_wildcard = require_interop_require_wildcard();
+    var _jsxruntime = require("react/jsx-runtime");
+    var _react = /* @__PURE__ */ _interop_require_wildcard._(require("react"));
+    var _sideeffect = /* @__PURE__ */ _interop_require_default._(require_side_effect());
+    var _ampcontextsharedruntime = require_amp_context_shared_runtime();
+    var _headmanagercontextsharedruntime = require_head_manager_context_shared_runtime();
+    var _ampmode = require_amp_mode();
+    var _warnonce = require_warn_once();
+    function defaultHead(inAmpMode) {
+      if (inAmpMode === void 0) inAmpMode = false;
+      const head = [
+        /* @__PURE__ */ (0, _jsxruntime.jsx)("meta", {
+          charSet: "utf-8"
+        }, "charset")
+      ];
+      if (!inAmpMode) {
+        head.push(/* @__PURE__ */ (0, _jsxruntime.jsx)("meta", {
+          name: "viewport",
+          content: "width=device-width"
+        }, "viewport"));
+      }
+      return head;
+    }
+    function onlyReactElement(list, child) {
+      if (typeof child === "string" || typeof child === "number") {
+        return list;
+      }
+      if (child.type === _react.default.Fragment) {
+        return list.concat(
+          // @ts-expect-error @types/react does not remove fragments but this could also return ReactPortal[]
+          _react.default.Children.toArray(child.props.children).reduce(
+            // @ts-expect-error @types/react does not remove fragments but this could also return ReactPortal[]
+            (fragmentList, fragmentChild) => {
+              if (typeof fragmentChild === "string" || typeof fragmentChild === "number") {
+                return fragmentList;
+              }
+              return fragmentList.concat(fragmentChild);
+            },
+            []
+          )
+        );
+      }
+      return list.concat(child);
+    }
+    var METATYPES = [
+      "name",
+      "httpEquiv",
+      "charSet",
+      "itemProp"
+    ];
+    function unique() {
+      const keys = /* @__PURE__ */ new Set();
+      const tags = /* @__PURE__ */ new Set();
+      const metaTypes = /* @__PURE__ */ new Set();
+      const metaCategories = {};
+      return (h) => {
+        let isUnique = true;
+        let hasKey = false;
+        if (h.key && typeof h.key !== "number" && h.key.indexOf("$") > 0) {
+          hasKey = true;
+          const key = h.key.slice(h.key.indexOf("$") + 1);
+          if (keys.has(key)) {
+            isUnique = false;
+          } else {
+            keys.add(key);
+          }
+        }
+        switch (h.type) {
+          case "title":
+          case "base":
+            if (tags.has(h.type)) {
+              isUnique = false;
+            } else {
+              tags.add(h.type);
+            }
+            break;
+          case "meta":
+            for (let i = 0, len = METATYPES.length; i < len; i++) {
+              const metatype = METATYPES[i];
+              if (!h.props.hasOwnProperty(metatype)) continue;
+              if (metatype === "charSet") {
+                if (metaTypes.has(metatype)) {
+                  isUnique = false;
+                } else {
+                  metaTypes.add(metatype);
+                }
+              } else {
+                const category = h.props[metatype];
+                const categories = metaCategories[metatype] || /* @__PURE__ */ new Set();
+                if ((metatype !== "name" || !hasKey) && categories.has(category)) {
+                  isUnique = false;
+                } else {
+                  categories.add(category);
+                  metaCategories[metatype] = categories;
+                }
+              }
+            }
+            break;
+        }
+        return isUnique;
+      };
+    }
+    function reduceComponents(headChildrenElements, props) {
+      const { inAmpMode } = props;
+      return headChildrenElements.reduce(onlyReactElement, []).reverse().concat(defaultHead(inAmpMode).reverse()).filter(unique()).reverse().map((c, i) => {
+        const key = c.key || i;
+        if (process.env.NODE_ENV !== "development" && process.env.__NEXT_OPTIMIZE_FONTS && !inAmpMode) {
+          if (c.type === "link" && c.props["href"] && // TODO(prateekbh@): Replace this with const from `constants` when the tree shaking works.
+          [
+            "https://fonts.googleapis.com/css",
+            "https://use.typekit.net/"
+          ].some((url) => c.props["href"].startsWith(url))) {
+            const newProps = {
+              ...c.props || {}
+            };
+            newProps["data-href"] = newProps["href"];
+            newProps["href"] = void 0;
+            newProps["data-optimized-fonts"] = true;
+            return /* @__PURE__ */ _react.default.cloneElement(c, newProps);
+          }
+        }
+        if (process.env.NODE_ENV === "development") {
+          if (c.type === "script" && c.props["type"] !== "application/ld+json") {
+            const srcMessage = c.props["src"] ? '<script> tag with src="' + c.props["src"] + '"' : "inline <script>";
+            (0, _warnonce.warnOnce)("Do not add <script> tags using next/head (see " + srcMessage + "). Use next/script instead. \nSee more info here: https://nextjs.org/docs/messages/no-script-tags-in-head-component");
+          } else if (c.type === "link" && c.props["rel"] === "stylesheet") {
+            (0, _warnonce.warnOnce)('Do not add stylesheets using next/head (see <link rel="stylesheet"> tag with href="' + c.props["href"] + '"). Use Document instead. \nSee more info here: https://nextjs.org/docs/messages/no-stylesheets-in-head-component');
+          }
+        }
+        return /* @__PURE__ */ _react.default.cloneElement(c, {
+          key
+        });
+      });
+    }
+    function Head(param) {
+      let { children } = param;
+      const ampState = (0, _react.useContext)(_ampcontextsharedruntime.AmpStateContext);
+      const headManager = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
+      return /* @__PURE__ */ (0, _jsxruntime.jsx)(_sideeffect.default, {
+        reduceComponentsToState: reduceComponents,
+        headManager,
+        inAmpMode: (0, _ampmode.isInAmpMode)(ampState),
+        children
+      });
+    }
+    var _default = Head;
+    if ((typeof exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js
+var require_image_config_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "ImageConfigContext", {
+      enumerable: true,
+      get: function() {
+        return ImageConfigContext;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _react = /* @__PURE__ */ _interop_require_default._(require("react"));
+    var _imageconfig = require_image_config();
+    var ImageConfigContext = _react.default.createContext(_imageconfig.imageConfigDefault);
+    if (process.env.NODE_ENV !== "production") {
+      ImageConfigContext.displayName = "ImageConfigContext";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router-context.shared-runtime.js
+var require_router_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/router-context.shared-runtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "RouterContext", {
+      enumerable: true,
+      get: function() {
+        return RouterContext;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _react = /* @__PURE__ */ _interop_require_default._(require("react"));
+    var RouterContext = _react.default.createContext(null);
+    if (process.env.NODE_ENV !== "production") {
+      RouterContext.displayName = "RouterContext";
+    }
+  }
+});
+
+// node_modules/next/dist/compiled/picomatch/index.js
+var require_picomatch = __commonJS({
+  "node_modules/next/dist/compiled/picomatch/index.js"(exports2, module2) {
+    (() => {
+      "use strict";
+      var t = { 170: (t2, e2, u2) => {
+        const n = u2(510);
+        const isWindows = () => {
+          if (typeof navigator !== "undefined" && navigator.platform) {
+            const t3 = navigator.platform.toLowerCase();
+            return t3 === "win32" || t3 === "windows";
+          }
+          if (typeof process !== "undefined" && process.platform) {
+            return process.platform === "win32";
+          }
+          return false;
+        };
+        function picomatch(t3, e3, u3 = false) {
+          if (e3 && (e3.windows === null || e3.windows === void 0)) {
+            e3 = { ...e3, windows: isWindows() };
+          }
+          return n(t3, e3, u3);
+        }
+        Object.assign(picomatch, n);
+        t2.exports = picomatch;
+      }, 154: (t2) => {
+        const e2 = "\\\\/";
+        const u2 = `[^${e2}]`;
+        const n = "\\.";
+        const o = "\\+";
+        const s = "\\?";
+        const r = "\\/";
+        const a = "(?=.)";
+        const i = "[^/]";
+        const c = `(?:${r}|$)`;
+        const p = `(?:^|${r})`;
+        const l = `${n}{1,2}${c}`;
+        const f = `(?!${n})`;
+        const A = `(?!${p}${l})`;
+        const _ = `(?!${n}{0,1}${c})`;
+        const R = `(?!${l})`;
+        const E = `[^.${r}]`;
+        const h = `${i}*?`;
+        const g = "/";
+        const b = { DOT_LITERAL: n, PLUS_LITERAL: o, QMARK_LITERAL: s, SLASH_LITERAL: r, ONE_CHAR: a, QMARK: i, END_ANCHOR: c, DOTS_SLASH: l, NO_DOT: f, NO_DOTS: A, NO_DOT_SLASH: _, NO_DOTS_SLASH: R, QMARK_NO_DOT: E, STAR: h, START_ANCHOR: p, SEP: g };
+        const C = { ...b, SLASH_LITERAL: `[${e2}]`, QMARK: u2, STAR: `${u2}*?`, DOTS_SLASH: `${n}{1,2}(?:[${e2}]|$)`, NO_DOT: `(?!${n})`, NO_DOTS: `(?!(?:^|[${e2}])${n}{1,2}(?:[${e2}]|$))`, NO_DOT_SLASH: `(?!${n}{0,1}(?:[${e2}]|$))`, NO_DOTS_SLASH: `(?!${n}{1,2}(?:[${e2}]|$))`, QMARK_NO_DOT: `[^.${e2}]`, START_ANCHOR: `(?:^|[${e2}])`, END_ANCHOR: `(?:[${e2}]|$)`, SEP: "\\" };
+        const y = { alnum: "a-zA-Z0-9", alpha: "a-zA-Z", ascii: "\\x00-\\x7F", blank: " \\t", cntrl: "\\x00-\\x1F\\x7F", digit: "0-9", graph: "\\x21-\\x7E", lower: "a-z", print: "\\x20-\\x7E ", punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~", space: " \\t\\r\\n\\v\\f", upper: "A-Z", word: "A-Za-z0-9_", xdigit: "A-Fa-f0-9" };
+        t2.exports = { MAX_LENGTH: 1024 * 64, POSIX_REGEX_SOURCE: y, REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, REPLACEMENTS: { "***": "*", "**/**": "**", "**/**/**": "**" }, CHAR_0: 48, CHAR_9: 57, CHAR_UPPERCASE_A: 65, CHAR_LOWERCASE_A: 97, CHAR_UPPERCASE_Z: 90, CHAR_LOWERCASE_Z: 122, CHAR_LEFT_PARENTHESES: 40, CHAR_RIGHT_PARENTHESES: 41, CHAR_ASTERISK: 42, CHAR_AMPERSAND: 38, CHAR_AT: 64, CHAR_BACKWARD_SLASH: 92, CHAR_CARRIAGE_RETURN: 13, CHAR_CIRCUMFLEX_ACCENT: 94, CHAR_COLON: 58, CHAR_COMMA: 44, CHAR_DOT: 46, CHAR_DOUBLE_QUOTE: 34, CHAR_EQUAL: 61, CHAR_EXCLAMATION_MARK: 33, CHAR_FORM_FEED: 12, CHAR_FORWARD_SLASH: 47, CHAR_GRAVE_ACCENT: 96, CHAR_HASH: 35, CHAR_HYPHEN_MINUS: 45, CHAR_LEFT_ANGLE_BRACKET: 60, CHAR_LEFT_CURLY_BRACE: 123, CHAR_LEFT_SQUARE_BRACKET: 91, CHAR_LINE_FEED: 10, CHAR_NO_BREAK_SPACE: 160, CHAR_PERCENT: 37, CHAR_PLUS: 43, CHAR_QUESTION_MARK: 63, CHAR_RIGHT_ANGLE_BRACKET: 62, CHAR_RIGHT_CURLY_BRACE: 125, CHAR_RIGHT_SQUARE_BRACKET: 93, CHAR_SEMICOLON: 59, CHAR_SINGLE_QUOTE: 39, CHAR_SPACE: 32, CHAR_TAB: 9, CHAR_UNDERSCORE: 95, CHAR_VERTICAL_LINE: 124, CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, extglobChars(t3) {
+          return { "!": { type: "negate", open: "(?:(?!(?:", close: `))${t3.STAR})` }, "?": { type: "qmark", open: "(?:", close: ")?" }, "+": { type: "plus", open: "(?:", close: ")+" }, "*": { type: "star", open: "(?:", close: ")*" }, "@": { type: "at", open: "(?:", close: ")" } };
+        }, globChars(t3) {
+          return t3 === true ? C : b;
+        } };
+      }, 697: (t2, e2, u2) => {
+        const n = u2(154);
+        const o = u2(96);
+        const { MAX_LENGTH: s, POSIX_REGEX_SOURCE: r, REGEX_NON_SPECIAL_CHARS: a, REGEX_SPECIAL_CHARS_BACKREF: i, REPLACEMENTS: c } = n;
+        const expandRange = (t3, e3) => {
+          if (typeof e3.expandRange === "function") {
+            return e3.expandRange(...t3, e3);
+          }
+          t3.sort();
+          const u3 = `[${t3.join("-")}]`;
+          try {
+            new RegExp(u3);
+          } catch (e4) {
+            return t3.map((t4) => o.escapeRegex(t4)).join("..");
+          }
+          return u3;
+        };
+        const syntaxError = (t3, e3) => `Missing ${t3}: "${e3}" - use "\\\\${e3}" to match literal characters`;
+        const parse = (t3, e3) => {
+          if (typeof t3 !== "string") {
+            throw new TypeError("Expected a string");
+          }
+          t3 = c[t3] || t3;
+          const u3 = { ...e3 };
+          const p = typeof u3.maxLength === "number" ? Math.min(s, u3.maxLength) : s;
+          let l = t3.length;
+          if (l > p) {
+            throw new SyntaxError(`Input length: ${l}, exceeds maximum allowed length: ${p}`);
+          }
+          const f = { type: "bos", value: "", output: u3.prepend || "" };
+          const A = [f];
+          const _ = u3.capture ? "" : "?:";
+          const R = n.globChars(u3.windows);
+          const E = n.extglobChars(R);
+          const { DOT_LITERAL: h, PLUS_LITERAL: g, SLASH_LITERAL: b, ONE_CHAR: C, DOTS_SLASH: y, NO_DOT: $, NO_DOT_SLASH: x, NO_DOTS_SLASH: S, QMARK: H, QMARK_NO_DOT: v, STAR: d, START_ANCHOR: L } = R;
+          const globstar = (t4) => `(${_}(?:(?!${L}${t4.dot ? y : h}).)*?)`;
+          const T = u3.dot ? "" : $;
+          const O = u3.dot ? H : v;
+          let k = u3.bash === true ? globstar(u3) : d;
+          if (u3.capture) {
+            k = `(${k})`;
+          }
+          if (typeof u3.noext === "boolean") {
+            u3.noextglob = u3.noext;
+          }
+          const m = { input: t3, index: -1, start: 0, dot: u3.dot === true, consumed: "", output: "", prefix: "", backtrack: false, negated: false, brackets: 0, braces: 0, parens: 0, quotes: 0, globstar: false, tokens: A };
+          t3 = o.removePrefix(t3, m);
+          l = t3.length;
+          const w = [];
+          const N = [];
+          const I = [];
+          let B = f;
+          let G;
+          const eos = () => m.index === l - 1;
+          const D = m.peek = (e4 = 1) => t3[m.index + e4];
+          const M = m.advance = () => t3[++m.index] || "";
+          const remaining = () => t3.slice(m.index + 1);
+          const consume = (t4 = "", e4 = 0) => {
+            m.consumed += t4;
+            m.index += e4;
+          };
+          const append = (t4) => {
+            m.output += t4.output != null ? t4.output : t4.value;
+            consume(t4.value);
+          };
+          const negate = () => {
+            let t4 = 1;
+            while (D() === "!" && (D(2) !== "(" || D(3) === "?")) {
+              M();
+              m.start++;
+              t4++;
+            }
+            if (t4 % 2 === 0) {
+              return false;
+            }
+            m.negated = true;
+            m.start++;
+            return true;
+          };
+          const increment = (t4) => {
+            m[t4]++;
+            I.push(t4);
+          };
+          const decrement = (t4) => {
+            m[t4]--;
+            I.pop();
+          };
+          const push = (t4) => {
+            if (B.type === "globstar") {
+              const e4 = m.braces > 0 && (t4.type === "comma" || t4.type === "brace");
+              const u4 = t4.extglob === true || w.length && (t4.type === "pipe" || t4.type === "paren");
+              if (t4.type !== "slash" && t4.type !== "paren" && !e4 && !u4) {
+                m.output = m.output.slice(0, -B.output.length);
+                B.type = "star";
+                B.value = "*";
+                B.output = k;
+                m.output += B.output;
+              }
+            }
+            if (w.length && t4.type !== "paren") {
+              w[w.length - 1].inner += t4.value;
+            }
+            if (t4.value || t4.output) append(t4);
+            if (B && B.type === "text" && t4.type === "text") {
+              B.output = (B.output || B.value) + t4.value;
+              B.value += t4.value;
+              return;
+            }
+            t4.prev = B;
+            A.push(t4);
+            B = t4;
+          };
+          const extglobOpen = (t4, e4) => {
+            const n2 = { ...E[e4], conditions: 1, inner: "" };
+            n2.prev = B;
+            n2.parens = m.parens;
+            n2.output = m.output;
+            const o2 = (u3.capture ? "(" : "") + n2.open;
+            increment("parens");
+            push({ type: t4, value: e4, output: m.output ? "" : C });
+            push({ type: "paren", extglob: true, value: M(), output: o2 });
+            w.push(n2);
+          };
+          const extglobClose = (t4) => {
+            let n2 = t4.close + (u3.capture ? ")" : "");
+            let o2;
+            if (t4.type === "negate") {
+              let s2 = k;
+              if (t4.inner && t4.inner.length > 1 && t4.inner.includes("/")) {
+                s2 = globstar(u3);
+              }
+              if (s2 !== k || eos() || /^\)+$/.test(remaining())) {
+                n2 = t4.close = `)$))${s2}`;
+              }
+              if (t4.inner.includes("*") && (o2 = remaining()) && /^\.[^\\/.]+$/.test(o2)) {
+                const u4 = parse(o2, { ...e3, fastpaths: false }).output;
+                n2 = t4.close = `)${u4})${s2})`;
+              }
+              if (t4.prev.type === "bos") {
+                m.negatedExtglob = true;
+              }
+            }
+            push({ type: "paren", extglob: true, value: G, output: n2 });
+            decrement("parens");
+          };
+          if (u3.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(t3)) {
+            let n2 = false;
+            let s2 = t3.replace(i, (t4, e4, u4, o2, s3, r2) => {
+              if (o2 === "\\") {
+                n2 = true;
+                return t4;
+              }
+              if (o2 === "?") {
+                if (e4) {
+                  return e4 + o2 + (s3 ? H.repeat(s3.length) : "");
+                }
+                if (r2 === 0) {
+                  return O + (s3 ? H.repeat(s3.length) : "");
+                }
+                return H.repeat(u4.length);
+              }
+              if (o2 === ".") {
+                return h.repeat(u4.length);
+              }
+              if (o2 === "*") {
+                if (e4) {
+                  return e4 + o2 + (s3 ? k : "");
+                }
+                return k;
+              }
+              return e4 ? t4 : `\\${t4}`;
+            });
+            if (n2 === true) {
+              if (u3.unescape === true) {
+                s2 = s2.replace(/\\/g, "");
+              } else {
+                s2 = s2.replace(/\\+/g, (t4) => t4.length % 2 === 0 ? "\\\\" : t4 ? "\\" : "");
+              }
+            }
+            if (s2 === t3 && u3.contains === true) {
+              m.output = t3;
+              return m;
+            }
+            m.output = o.wrapOutput(s2, m, e3);
+            return m;
+          }
+          while (!eos()) {
+            G = M();
+            if (G === "\0") {
+              continue;
+            }
+            if (G === "\\") {
+              const t4 = D();
+              if (t4 === "/" && u3.bash !== true) {
+                continue;
+              }
+              if (t4 === "." || t4 === ";") {
+                continue;
+              }
+              if (!t4) {
+                G += "\\";
+                push({ type: "text", value: G });
+                continue;
+              }
+              const e5 = /^\\+/.exec(remaining());
+              let n3 = 0;
+              if (e5 && e5[0].length > 2) {
+                n3 = e5[0].length;
+                m.index += n3;
+                if (n3 % 2 !== 0) {
+                  G += "\\";
+                }
+              }
+              if (u3.unescape === true) {
+                G = M();
+              } else {
+                G += M();
+              }
+              if (m.brackets === 0) {
+                push({ type: "text", value: G });
+                continue;
+              }
+            }
+            if (m.brackets > 0 && (G !== "]" || B.value === "[" || B.value === "[^")) {
+              if (u3.posix !== false && G === ":") {
+                const t4 = B.value.slice(1);
+                if (t4.includes("[")) {
+                  B.posix = true;
+                  if (t4.includes(":")) {
+                    const t5 = B.value.lastIndexOf("[");
+                    const e5 = B.value.slice(0, t5);
+                    const u4 = B.value.slice(t5 + 2);
+                    const n3 = r[u4];
+                    if (n3) {
+                      B.value = e5 + n3;
+                      m.backtrack = true;
+                      M();
+                      if (!f.output && A.indexOf(B) === 1) {
+                        f.output = C;
+                      }
+                      continue;
+                    }
+                  }
+                }
+              }
+              if (G === "[" && D() !== ":" || G === "-" && D() === "]") {
+                G = `\\${G}`;
+              }
+              if (G === "]" && (B.value === "[" || B.value === "[^")) {
+                G = `\\${G}`;
+              }
+              if (u3.posix === true && G === "!" && B.value === "[") {
+                G = "^";
+              }
+              B.value += G;
+              append({ value: G });
+              continue;
+            }
+            if (m.quotes === 1 && G !== '"') {
+              G = o.escapeRegex(G);
+              B.value += G;
+              append({ value: G });
+              continue;
+            }
+            if (G === '"') {
+              m.quotes = m.quotes === 1 ? 0 : 1;
+              if (u3.keepQuotes === true) {
+                push({ type: "text", value: G });
+              }
+              continue;
+            }
+            if (G === "(") {
+              increment("parens");
+              push({ type: "paren", value: G });
+              continue;
+            }
+            if (G === ")") {
+              if (m.parens === 0 && u3.strictBrackets === true) {
+                throw new SyntaxError(syntaxError("opening", "("));
+              }
+              const t4 = w[w.length - 1];
+              if (t4 && m.parens === t4.parens + 1) {
+                extglobClose(w.pop());
+                continue;
+              }
+              push({ type: "paren", value: G, output: m.parens ? ")" : "\\)" });
+              decrement("parens");
+              continue;
+            }
+            if (G === "[") {
+              if (u3.nobracket === true || !remaining().includes("]")) {
+                if (u3.nobracket !== true && u3.strictBrackets === true) {
+                  throw new SyntaxError(syntaxError("closing", "]"));
+                }
+                G = `\\${G}`;
+              } else {
+                increment("brackets");
+              }
+              push({ type: "bracket", value: G });
+              continue;
+            }
+            if (G === "]") {
+              if (u3.nobracket === true || B && B.type === "bracket" && B.value.length === 1) {
+                push({ type: "text", value: G, output: `\\${G}` });
+                continue;
+              }
+              if (m.brackets === 0) {
+                if (u3.strictBrackets === true) {
+                  throw new SyntaxError(syntaxError("opening", "["));
+                }
+                push({ type: "text", value: G, output: `\\${G}` });
+                continue;
+              }
+              decrement("brackets");
+              const t4 = B.value.slice(1);
+              if (B.posix !== true && t4[0] === "^" && !t4.includes("/")) {
+                G = `/${G}`;
+              }
+              B.value += G;
+              append({ value: G });
+              if (u3.literalBrackets === false || o.hasRegexChars(t4)) {
+                continue;
+              }
+              const e5 = o.escapeRegex(B.value);
+              m.output = m.output.slice(0, -B.value.length);
+              if (u3.literalBrackets === true) {
+                m.output += e5;
+                B.value = e5;
+                continue;
+              }
+              B.value = `(${_}${e5}|${B.value})`;
+              m.output += B.value;
+              continue;
+            }
+            if (G === "{" && u3.nobrace !== true) {
+              increment("braces");
+              const t4 = { type: "brace", value: G, output: "(", outputIndex: m.output.length, tokensIndex: m.tokens.length };
+              N.push(t4);
+              push(t4);
+              continue;
+            }
+            if (G === "}") {
+              const t4 = N[N.length - 1];
+              if (u3.nobrace === true || !t4) {
+                push({ type: "text", value: G, output: G });
+                continue;
+              }
+              let e5 = ")";
+              if (t4.dots === true) {
+                const t5 = A.slice();
+                const n3 = [];
+                for (let e6 = t5.length - 1; e6 >= 0; e6--) {
+                  A.pop();
+                  if (t5[e6].type === "brace") {
+                    break;
+                  }
+                  if (t5[e6].type !== "dots") {
+                    n3.unshift(t5[e6].value);
+                  }
+                }
+                e5 = expandRange(n3, u3);
+                m.backtrack = true;
+              }
+              if (t4.comma !== true && t4.dots !== true) {
+                const u4 = m.output.slice(0, t4.outputIndex);
+                const n3 = m.tokens.slice(t4.tokensIndex);
+                t4.value = t4.output = "\\{";
+                G = e5 = "\\}";
+                m.output = u4;
+                for (const t5 of n3) {
+                  m.output += t5.output || t5.value;
+                }
+              }
+              push({ type: "brace", value: G, output: e5 });
+              decrement("braces");
+              N.pop();
+              continue;
+            }
+            if (G === "|") {
+              if (w.length > 0) {
+                w[w.length - 1].conditions++;
+              }
+              push({ type: "text", value: G });
+              continue;
+            }
+            if (G === ",") {
+              let t4 = G;
+              const e5 = N[N.length - 1];
+              if (e5 && I[I.length - 1] === "braces") {
+                e5.comma = true;
+                t4 = "|";
+              }
+              push({ type: "comma", value: G, output: t4 });
+              continue;
+            }
+            if (G === "/") {
+              if (B.type === "dot" && m.index === m.start + 1) {
+                m.start = m.index + 1;
+                m.consumed = "";
+                m.output = "";
+                A.pop();
+                B = f;
+                continue;
+              }
+              push({ type: "slash", value: G, output: b });
+              continue;
+            }
+            if (G === ".") {
+              if (m.braces > 0 && B.type === "dot") {
+                if (B.value === ".") B.output = h;
+                const t4 = N[N.length - 1];
+                B.type = "dots";
+                B.output += G;
+                B.value += G;
+                t4.dots = true;
+                continue;
+              }
+              if (m.braces + m.parens === 0 && B.type !== "bos" && B.type !== "slash") {
+                push({ type: "text", value: G, output: h });
+                continue;
+              }
+              push({ type: "dot", value: G, output: h });
+              continue;
+            }
+            if (G === "?") {
+              const t4 = B && B.value === "(";
+              if (!t4 && u3.noextglob !== true && D() === "(" && D(2) !== "?") {
+                extglobOpen("qmark", G);
+                continue;
+              }
+              if (B && B.type === "paren") {
+                const t5 = D();
+                let e5 = G;
+                if (B.value === "(" && !/[!=<:]/.test(t5) || t5 === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+                  e5 = `\\${G}`;
+                }
+                push({ type: "text", value: G, output: e5 });
+                continue;
+              }
+              if (u3.dot !== true && (B.type === "slash" || B.type === "bos")) {
+                push({ type: "qmark", value: G, output: v });
+                continue;
+              }
+              push({ type: "qmark", value: G, output: H });
+              continue;
+            }
+            if (G === "!") {
+              if (u3.noextglob !== true && D() === "(") {
+                if (D(2) !== "?" || !/[!=<:]/.test(D(3))) {
+                  extglobOpen("negate", G);
+                  continue;
+                }
+              }
+              if (u3.nonegate !== true && m.index === 0) {
+                negate();
+                continue;
+              }
+            }
+            if (G === "+") {
+              if (u3.noextglob !== true && D() === "(" && D(2) !== "?") {
+                extglobOpen("plus", G);
+                continue;
+              }
+              if (B && B.value === "(" || u3.regex === false) {
+                push({ type: "plus", value: G, output: g });
+                continue;
+              }
+              if (B && (B.type === "bracket" || B.type === "paren" || B.type === "brace") || m.parens > 0) {
+                push({ type: "plus", value: G });
+                continue;
+              }
+              push({ type: "plus", value: g });
+              continue;
+            }
+            if (G === "@") {
+              if (u3.noextglob !== true && D() === "(" && D(2) !== "?") {
+                push({ type: "at", extglob: true, value: G, output: "" });
+                continue;
+              }
+              push({ type: "text", value: G });
+              continue;
+            }
+            if (G !== "*") {
+              if (G === "$" || G === "^") {
+                G = `\\${G}`;
+              }
+              const t4 = a.exec(remaining());
+              if (t4) {
+                G += t4[0];
+                m.index += t4[0].length;
+              }
+              push({ type: "text", value: G });
+              continue;
+            }
+            if (B && (B.type === "globstar" || B.star === true)) {
+              B.type = "star";
+              B.star = true;
+              B.value += G;
+              B.output = k;
+              m.backtrack = true;
+              m.globstar = true;
+              consume(G);
+              continue;
+            }
+            let e4 = remaining();
+            if (u3.noextglob !== true && /^\([^?]/.test(e4)) {
+              extglobOpen("star", G);
+              continue;
+            }
+            if (B.type === "star") {
+              if (u3.noglobstar === true) {
+                consume(G);
+                continue;
+              }
+              const n3 = B.prev;
+              const o2 = n3.prev;
+              const s2 = n3.type === "slash" || n3.type === "bos";
+              const r2 = o2 && (o2.type === "star" || o2.type === "globstar");
+              if (u3.bash === true && (!s2 || e4[0] && e4[0] !== "/")) {
+                push({ type: "star", value: G, output: "" });
+                continue;
+              }
+              const a2 = m.braces > 0 && (n3.type === "comma" || n3.type === "brace");
+              const i2 = w.length && (n3.type === "pipe" || n3.type === "paren");
+              if (!s2 && n3.type !== "paren" && !a2 && !i2) {
+                push({ type: "star", value: G, output: "" });
+                continue;
+              }
+              while (e4.slice(0, 3) === "/**") {
+                const u4 = t3[m.index + 4];
+                if (u4 && u4 !== "/") {
+                  break;
+                }
+                e4 = e4.slice(3);
+                consume("/**", 3);
+              }
+              if (n3.type === "bos" && eos()) {
+                B.type = "globstar";
+                B.value += G;
+                B.output = globstar(u3);
+                m.output = B.output;
+                m.globstar = true;
+                consume(G);
+                continue;
+              }
+              if (n3.type === "slash" && n3.prev.type !== "bos" && !r2 && eos()) {
+                m.output = m.output.slice(0, -(n3.output + B.output).length);
+                n3.output = `(?:${n3.output}`;
+                B.type = "globstar";
+                B.output = globstar(u3) + (u3.strictSlashes ? ")" : "|$)");
+                B.value += G;
+                m.globstar = true;
+                m.output += n3.output + B.output;
+                consume(G);
+                continue;
+              }
+              if (n3.type === "slash" && n3.prev.type !== "bos" && e4[0] === "/") {
+                const t4 = e4[1] !== void 0 ? "|$" : "";
+                m.output = m.output.slice(0, -(n3.output + B.output).length);
+                n3.output = `(?:${n3.output}`;
+                B.type = "globstar";
+                B.output = `${globstar(u3)}${b}|${b}${t4})`;
+                B.value += G;
+                m.output += n3.output + B.output;
+                m.globstar = true;
+                consume(G + M());
+                push({ type: "slash", value: "/", output: "" });
+                continue;
+              }
+              if (n3.type === "bos" && e4[0] === "/") {
+                B.type = "globstar";
+                B.value += G;
+                B.output = `(?:^|${b}|${globstar(u3)}${b})`;
+                m.output = B.output;
+                m.globstar = true;
+                consume(G + M());
+                push({ type: "slash", value: "/", output: "" });
+                continue;
+              }
+              m.output = m.output.slice(0, -B.output.length);
+              B.type = "globstar";
+              B.output = globstar(u3);
+              B.value += G;
+              m.output += B.output;
+              m.globstar = true;
+              consume(G);
+              continue;
+            }
+            const n2 = { type: "star", value: G, output: k };
+            if (u3.bash === true) {
+              n2.output = ".*?";
+              if (B.type === "bos" || B.type === "slash") {
+                n2.output = T + n2.output;
+              }
+              push(n2);
+              continue;
+            }
+            if (B && (B.type === "bracket" || B.type === "paren") && u3.regex === true) {
+              n2.output = G;
+              push(n2);
+              continue;
+            }
+            if (m.index === m.start || B.type === "slash" || B.type === "dot") {
+              if (B.type === "dot") {
+                m.output += x;
+                B.output += x;
+              } else if (u3.dot === true) {
+                m.output += S;
+                B.output += S;
+              } else {
+                m.output += T;
+                B.output += T;
+              }
+              if (D() !== "*") {
+                m.output += C;
+                B.output += C;
+              }
+            }
+            push(n2);
+          }
+          while (m.brackets > 0) {
+            if (u3.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+            m.output = o.escapeLast(m.output, "[");
+            decrement("brackets");
+          }
+          while (m.parens > 0) {
+            if (u3.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+            m.output = o.escapeLast(m.output, "(");
+            decrement("parens");
+          }
+          while (m.braces > 0) {
+            if (u3.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+            m.output = o.escapeLast(m.output, "{");
+            decrement("braces");
+          }
+          if (u3.strictSlashes !== true && (B.type === "star" || B.type === "bracket")) {
+            push({ type: "maybe_slash", value: "", output: `${b}?` });
+          }
+          if (m.backtrack === true) {
+            m.output = "";
+            for (const t4 of m.tokens) {
+              m.output += t4.output != null ? t4.output : t4.value;
+              if (t4.suffix) {
+                m.output += t4.suffix;
+              }
+            }
+          }
+          return m;
+        };
+        parse.fastpaths = (t3, e3) => {
+          const u3 = { ...e3 };
+          const r2 = typeof u3.maxLength === "number" ? Math.min(s, u3.maxLength) : s;
+          const a2 = t3.length;
+          if (a2 > r2) {
+            throw new SyntaxError(`Input length: ${a2}, exceeds maximum allowed length: ${r2}`);
+          }
+          t3 = c[t3] || t3;
+          const { DOT_LITERAL: i2, SLASH_LITERAL: p, ONE_CHAR: l, DOTS_SLASH: f, NO_DOT: A, NO_DOTS: _, NO_DOTS_SLASH: R, STAR: E, START_ANCHOR: h } = n.globChars(u3.windows);
+          const g = u3.dot ? _ : A;
+          const b = u3.dot ? R : A;
+          const C = u3.capture ? "" : "?:";
+          const y = { negated: false, prefix: "" };
+          let $ = u3.bash === true ? ".*?" : E;
+          if (u3.capture) {
+            $ = `(${$})`;
+          }
+          const globstar = (t4) => {
+            if (t4.noglobstar === true) return $;
+            return `(${C}(?:(?!${h}${t4.dot ? f : i2}).)*?)`;
+          };
+          const create = (t4) => {
+            switch (t4) {
+              case "*":
+                return `${g}${l}${$}`;
+              case ".*":
+                return `${i2}${l}${$}`;
+              case "*.*":
+                return `${g}${$}${i2}${l}${$}`;
+              case "*/*":
+                return `${g}${$}${p}${l}${b}${$}`;
+              case "**":
+                return g + globstar(u3);
+              case "**/*":
+                return `(?:${g}${globstar(u3)}${p})?${b}${l}${$}`;
+              case "**/*.*":
+                return `(?:${g}${globstar(u3)}${p})?${b}${$}${i2}${l}${$}`;
+              case "**/.*":
+                return `(?:${g}${globstar(u3)}${p})?${i2}${l}${$}`;
+              default: {
+                const e4 = /^(.*?)\.(\w+)$/.exec(t4);
+                if (!e4) return;
+                const u4 = create(e4[1]);
+                if (!u4) return;
+                return u4 + i2 + e4[2];
+              }
+            }
+          };
+          const x = o.removePrefix(t3, y);
+          let S = create(x);
+          if (S && u3.strictSlashes !== true) {
+            S += `${p}?`;
+          }
+          return S;
+        };
+        t2.exports = parse;
+      }, 510: (t2, e2, u2) => {
+        const n = u2(716);
+        const o = u2(697);
+        const s = u2(96);
+        const r = u2(154);
+        const isObject = (t3) => t3 && typeof t3 === "object" && !Array.isArray(t3);
+        const picomatch = (t3, e3, u3 = false) => {
+          if (Array.isArray(t3)) {
+            const n3 = t3.map((t4) => picomatch(t4, e3, u3));
+            const arrayMatcher = (t4) => {
+              for (const e4 of n3) {
+                const u4 = e4(t4);
+                if (u4) return u4;
+              }
+              return false;
+            };
+            return arrayMatcher;
+          }
+          const n2 = isObject(t3) && t3.tokens && t3.input;
+          if (t3 === "" || typeof t3 !== "string" && !n2) {
+            throw new TypeError("Expected pattern to be a non-empty string");
+          }
+          const o2 = e3 || {};
+          const s2 = o2.windows;
+          const r2 = n2 ? picomatch.compileRe(t3, e3) : picomatch.makeRe(t3, e3, false, true);
+          const a = r2.state;
+          delete r2.state;
+          let isIgnored = () => false;
+          if (o2.ignore) {
+            const t4 = { ...e3, ignore: null, onMatch: null, onResult: null };
+            isIgnored = picomatch(o2.ignore, t4, u3);
+          }
+          const matcher = (u4, n3 = false) => {
+            const { isMatch: i, match: c, output: p } = picomatch.test(u4, r2, e3, { glob: t3, posix: s2 });
+            const l = { glob: t3, state: a, regex: r2, posix: s2, input: u4, output: p, match: c, isMatch: i };
+            if (typeof o2.onResult === "function") {
+              o2.onResult(l);
+            }
+            if (i === false) {
+              l.isMatch = false;
+              return n3 ? l : false;
+            }
+            if (isIgnored(u4)) {
+              if (typeof o2.onIgnore === "function") {
+                o2.onIgnore(l);
+              }
+              l.isMatch = false;
+              return n3 ? l : false;
+            }
+            if (typeof o2.onMatch === "function") {
+              o2.onMatch(l);
+            }
+            return n3 ? l : true;
+          };
+          if (u3) {
+            matcher.state = a;
+          }
+          return matcher;
+        };
+        picomatch.test = (t3, e3, u3, { glob: n2, posix: o2 } = {}) => {
+          if (typeof t3 !== "string") {
+            throw new TypeError("Expected input to be a string");
+          }
+          if (t3 === "") {
+            return { isMatch: false, output: "" };
+          }
+          const r2 = u3 || {};
+          const a = r2.format || (o2 ? s.toPosixSlashes : null);
+          let i = t3 === n2;
+          let c = i && a ? a(t3) : t3;
+          if (i === false) {
+            c = a ? a(t3) : t3;
+            i = c === n2;
+          }
+          if (i === false || r2.capture === true) {
+            if (r2.matchBase === true || r2.basename === true) {
+              i = picomatch.matchBase(t3, e3, u3, o2);
+            } else {
+              i = e3.exec(c);
+            }
+          }
+          return { isMatch: Boolean(i), match: i, output: c };
+        };
+        picomatch.matchBase = (t3, e3, u3) => {
+          const n2 = e3 instanceof RegExp ? e3 : picomatch.makeRe(e3, u3);
+          return n2.test(s.basename(t3));
+        };
+        picomatch.isMatch = (t3, e3, u3) => picomatch(e3, u3)(t3);
+        picomatch.parse = (t3, e3) => {
+          if (Array.isArray(t3)) return t3.map((t4) => picomatch.parse(t4, e3));
+          return o(t3, { ...e3, fastpaths: false });
+        };
+        picomatch.scan = (t3, e3) => n(t3, e3);
+        picomatch.compileRe = (t3, e3, u3 = false, n2 = false) => {
+          if (u3 === true) {
+            return t3.output;
+          }
+          const o2 = e3 || {};
+          const s2 = o2.contains ? "" : "^";
+          const r2 = o2.contains ? "" : "$";
+          let a = `${s2}(?:${t3.output})${r2}`;
+          if (t3 && t3.negated === true) {
+            a = `^(?!${a}).*$`;
+          }
+          const i = picomatch.toRegex(a, e3);
+          if (n2 === true) {
+            i.state = t3;
+          }
+          return i;
+        };
+        picomatch.makeRe = (t3, e3 = {}, u3 = false, n2 = false) => {
+          if (!t3 || typeof t3 !== "string") {
+            throw new TypeError("Expected a non-empty string");
+          }
+          let s2 = { negated: false, fastpaths: true };
+          if (e3.fastpaths !== false && (t3[0] === "." || t3[0] === "*")) {
+            s2.output = o.fastpaths(t3, e3);
+          }
+          if (!s2.output) {
+            s2 = o(t3, e3);
+          }
+          return picomatch.compileRe(s2, e3, u3, n2);
+        };
+        picomatch.toRegex = (t3, e3) => {
+          try {
+            const u3 = e3 || {};
+            return new RegExp(t3, u3.flags || (u3.nocase ? "i" : ""));
+          } catch (t4) {
+            if (e3 && e3.debug === true) throw t4;
+            return /$^/;
+          }
+        };
+        picomatch.constants = r;
+        t2.exports = picomatch;
+      }, 716: (t2, e2, u2) => {
+        const n = u2(96);
+        const { CHAR_ASTERISK: o, CHAR_AT: s, CHAR_BACKWARD_SLASH: r, CHAR_COMMA: a, CHAR_DOT: i, CHAR_EXCLAMATION_MARK: c, CHAR_FORWARD_SLASH: p, CHAR_LEFT_CURLY_BRACE: l, CHAR_LEFT_PARENTHESES: f, CHAR_LEFT_SQUARE_BRACKET: A, CHAR_PLUS: _, CHAR_QUESTION_MARK: R, CHAR_RIGHT_CURLY_BRACE: E, CHAR_RIGHT_PARENTHESES: h, CHAR_RIGHT_SQUARE_BRACKET: g } = u2(154);
+        const isPathSeparator = (t3) => t3 === p || t3 === r;
+        const depth = (t3) => {
+          if (t3.isPrefix !== true) {
+            t3.depth = t3.isGlobstar ? Infinity : 1;
+          }
+        };
+        const scan = (t3, e3) => {
+          const u3 = e3 || {};
+          const b = t3.length - 1;
+          const C = u3.parts === true || u3.scanToEnd === true;
+          const y = [];
+          const $ = [];
+          const x = [];
+          let S = t3;
+          let H = -1;
+          let v = 0;
+          let d = 0;
+          let L = false;
+          let T = false;
+          let O = false;
+          let k = false;
+          let m = false;
+          let w = false;
+          let N = false;
+          let I = false;
+          let B = false;
+          let G = false;
+          let D = 0;
+          let M;
+          let P;
+          let K = { value: "", depth: 0, isGlob: false };
+          const eos = () => H >= b;
+          const peek = () => S.charCodeAt(H + 1);
+          const advance = () => {
+            M = P;
+            return S.charCodeAt(++H);
+          };
+          while (H < b) {
+            P = advance();
+            let t4;
+            if (P === r) {
+              N = K.backslashes = true;
+              P = advance();
+              if (P === l) {
+                w = true;
+              }
+              continue;
+            }
+            if (w === true || P === l) {
+              D++;
+              while (eos() !== true && (P = advance())) {
+                if (P === r) {
+                  N = K.backslashes = true;
+                  advance();
+                  continue;
+                }
+                if (P === l) {
+                  D++;
+                  continue;
+                }
+                if (w !== true && P === i && (P = advance()) === i) {
+                  L = K.isBrace = true;
+                  O = K.isGlob = true;
+                  G = true;
+                  if (C === true) {
+                    continue;
+                  }
+                  break;
+                }
+                if (w !== true && P === a) {
+                  L = K.isBrace = true;
+                  O = K.isGlob = true;
+                  G = true;
+                  if (C === true) {
+                    continue;
+                  }
+                  break;
+                }
+                if (P === E) {
+                  D--;
+                  if (D === 0) {
+                    w = false;
+                    L = K.isBrace = true;
+                    G = true;
+                    break;
+                  }
+                }
+              }
+              if (C === true) {
+                continue;
+              }
+              break;
+            }
+            if (P === p) {
+              y.push(H);
+              $.push(K);
+              K = { value: "", depth: 0, isGlob: false };
+              if (G === true) continue;
+              if (M === i && H === v + 1) {
+                v += 2;
+                continue;
+              }
+              d = H + 1;
+              continue;
+            }
+            if (u3.noext !== true) {
+              const t5 = P === _ || P === s || P === o || P === R || P === c;
+              if (t5 === true && peek() === f) {
+                O = K.isGlob = true;
+                k = K.isExtglob = true;
+                G = true;
+                if (P === c && H === v) {
+                  B = true;
+                }
+                if (C === true) {
+                  while (eos() !== true && (P = advance())) {
+                    if (P === r) {
+                      N = K.backslashes = true;
+                      P = advance();
+                      continue;
+                    }
+                    if (P === h) {
+                      O = K.isGlob = true;
+                      G = true;
+                      break;
+                    }
+                  }
+                  continue;
+                }
+                break;
+              }
+            }
+            if (P === o) {
+              if (M === o) m = K.isGlobstar = true;
+              O = K.isGlob = true;
+              G = true;
+              if (C === true) {
+                continue;
+              }
+              break;
+            }
+            if (P === R) {
+              O = K.isGlob = true;
+              G = true;
+              if (C === true) {
+                continue;
+              }
+              break;
+            }
+            if (P === A) {
+              while (eos() !== true && (t4 = advance())) {
+                if (t4 === r) {
+                  N = K.backslashes = true;
+                  advance();
+                  continue;
+                }
+                if (t4 === g) {
+                  T = K.isBracket = true;
+                  O = K.isGlob = true;
+                  G = true;
+                  break;
+                }
+              }
+              if (C === true) {
+                continue;
+              }
+              break;
+            }
+            if (u3.nonegate !== true && P === c && H === v) {
+              I = K.negated = true;
+              v++;
+              continue;
+            }
+            if (u3.noparen !== true && P === f) {
+              O = K.isGlob = true;
+              if (C === true) {
+                while (eos() !== true && (P = advance())) {
+                  if (P === f) {
+                    N = K.backslashes = true;
+                    P = advance();
+                    continue;
+                  }
+                  if (P === h) {
+                    G = true;
+                    break;
+                  }
+                }
+                continue;
+              }
+              break;
+            }
+            if (O === true) {
+              G = true;
+              if (C === true) {
+                continue;
+              }
+              break;
+            }
+          }
+          if (u3.noext === true) {
+            k = false;
+            O = false;
+          }
+          let U = S;
+          let X2 = "";
+          let F = "";
+          if (v > 0) {
+            X2 = S.slice(0, v);
+            S = S.slice(v);
+            d -= v;
+          }
+          if (U && O === true && d > 0) {
+            U = S.slice(0, d);
+            F = S.slice(d);
+          } else if (O === true) {
+            U = "";
+            F = S;
+          } else {
+            U = S;
+          }
+          if (U && U !== "" && U !== "/" && U !== S) {
+            if (isPathSeparator(U.charCodeAt(U.length - 1))) {
+              U = U.slice(0, -1);
+            }
+          }
+          if (u3.unescape === true) {
+            if (F) F = n.removeBackslashes(F);
+            if (U && N === true) {
+              U = n.removeBackslashes(U);
+            }
+          }
+          const Q = { prefix: X2, input: t3, start: v, base: U, glob: F, isBrace: L, isBracket: T, isGlob: O, isExtglob: k, isGlobstar: m, negated: I, negatedExtglob: B };
+          if (u3.tokens === true) {
+            Q.maxDepth = 0;
+            if (!isPathSeparator(P)) {
+              $.push(K);
+            }
+            Q.tokens = $;
+          }
+          if (u3.parts === true || u3.tokens === true) {
+            let e4;
+            for (let n2 = 0; n2 < y.length; n2++) {
+              const o2 = e4 ? e4 + 1 : v;
+              const s2 = y[n2];
+              const r2 = t3.slice(o2, s2);
+              if (u3.tokens) {
+                if (n2 === 0 && v !== 0) {
+                  $[n2].isPrefix = true;
+                  $[n2].value = X2;
+                } else {
+                  $[n2].value = r2;
+                }
+                depth($[n2]);
+                Q.maxDepth += $[n2].depth;
+              }
+              if (n2 !== 0 || r2 !== "") {
+                x.push(r2);
+              }
+              e4 = s2;
+            }
+            if (e4 && e4 + 1 < t3.length) {
+              const n2 = t3.slice(e4 + 1);
+              x.push(n2);
+              if (u3.tokens) {
+                $[$.length - 1].value = n2;
+                depth($[$.length - 1]);
+                Q.maxDepth += $[$.length - 1].depth;
+              }
+            }
+            Q.slashes = y;
+            Q.parts = x;
+          }
+          return Q;
+        };
+        t2.exports = scan;
+      }, 96: (t2, e2, u2) => {
+        const { REGEX_BACKSLASH: n, REGEX_REMOVE_BACKSLASH: o, REGEX_SPECIAL_CHARS: s, REGEX_SPECIAL_CHARS_GLOBAL: r } = u2(154);
+        e2.isObject = (t3) => t3 !== null && typeof t3 === "object" && !Array.isArray(t3);
+        e2.hasRegexChars = (t3) => s.test(t3);
+        e2.isRegexChar = (t3) => t3.length === 1 && e2.hasRegexChars(t3);
+        e2.escapeRegex = (t3) => t3.replace(r, "\\$1");
+        e2.toPosixSlashes = (t3) => t3.replace(n, "/");
+        e2.removeBackslashes = (t3) => t3.replace(o, (t4) => t4 === "\\" ? "" : t4);
+        e2.escapeLast = (t3, u3, n2) => {
+          const o2 = t3.lastIndexOf(u3, n2);
+          if (o2 === -1) return t3;
+          if (t3[o2 - 1] === "\\") return e2.escapeLast(t3, u3, o2 - 1);
+          return `${t3.slice(0, o2)}\\${t3.slice(o2)}`;
+        };
+        e2.removePrefix = (t3, e3 = {}) => {
+          let u3 = t3;
+          if (u3.startsWith("./")) {
+            u3 = u3.slice(2);
+            e3.prefix = "./";
+          }
+          return u3;
+        };
+        e2.wrapOutput = (t3, e3 = {}, u3 = {}) => {
+          const n2 = u3.contains ? "" : "^";
+          const o2 = u3.contains ? "" : "$";
+          let s2 = `${n2}(?:${t3})${o2}`;
+          if (e3.negated === true) {
+            s2 = `(?:^(?!${s2}).*$)`;
+          }
+          return s2;
+        };
+        e2.basename = (t3, { windows: e3 } = {}) => {
+          const u3 = t3.split(e3 ? /[\\/]/ : "/");
+          const n2 = u3[u3.length - 1];
+          if (n2 === "") {
+            return u3[u3.length - 2];
+          }
+          return n2;
+        };
+      } };
+      var e = {};
+      function __nccwpck_require__(u2) {
+        var n = e[u2];
+        if (n !== void 0) {
+          return n.exports;
+        }
+        var o = e[u2] = { exports: {} };
+        var s = true;
+        try {
+          t[u2](o, o.exports, __nccwpck_require__);
+          s = false;
+        } finally {
+          if (s) delete e[u2];
+        }
+        return o.exports;
+      }
+      if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = __dirname + "/";
+      var u = __nccwpck_require__(170);
+      module2.exports = u;
+    })();
+  }
+});
+
+// node_modules/next/dist/shared/lib/match-local-pattern.js
+var require_match_local_pattern = __commonJS({
+  "node_modules/next/dist/shared/lib/match-local-pattern.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      hasLocalMatch: function() {
+        return hasLocalMatch;
+      },
+      matchLocalPattern: function() {
+        return matchLocalPattern;
+      }
+    });
+    var _picomatch = require_picomatch();
+    function matchLocalPattern(pattern, url) {
+      if (pattern.search !== void 0) {
+        if (pattern.search !== url.search) {
+          return false;
+        }
+      }
+      var _pattern_pathname;
+      if (!(0, _picomatch.makeRe)((_pattern_pathname = pattern.pathname) != null ? _pattern_pathname : "**", {
+        dot: true
+      }).test(url.pathname)) {
+        return false;
+      }
+      return true;
+    }
+    function hasLocalMatch(localPatterns, urlPathAndQuery) {
+      if (!localPatterns) {
+        return true;
+      }
+      const url = new URL(urlPathAndQuery, "http://n");
+      return localPatterns.some((p) => matchLocalPattern(p, url));
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/match-remote-pattern.js
+var require_match_remote_pattern = __commonJS({
+  "node_modules/next/dist/shared/lib/match-remote-pattern.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      hasRemoteMatch: function() {
+        return hasRemoteMatch;
+      },
+      matchRemotePattern: function() {
+        return matchRemotePattern;
+      }
+    });
+    var _picomatch = require_picomatch();
+    function matchRemotePattern(pattern, url) {
+      if (pattern.protocol !== void 0) {
+        if (pattern.protocol.replace(/:$/, "") !== url.protocol.replace(/:$/, "")) {
+          return false;
+        }
+      }
+      if (pattern.port !== void 0) {
+        if (pattern.port !== url.port) {
+          return false;
+        }
+      }
+      if (pattern.hostname === void 0) {
+        throw Object.defineProperty(new Error("Pattern should define hostname but found\n" + JSON.stringify(pattern)), "__NEXT_ERROR_CODE", {
+          value: "E410",
+          enumerable: false,
+          configurable: true
+        });
+      } else {
+        if (!(0, _picomatch.makeRe)(pattern.hostname).test(url.hostname)) {
+          return false;
+        }
+      }
+      if (pattern.search !== void 0) {
+        if (pattern.search !== url.search) {
+          return false;
+        }
+      }
+      var _pattern_pathname;
+      if (!(0, _picomatch.makeRe)((_pattern_pathname = pattern.pathname) != null ? _pattern_pathname : "**", {
+        dot: true
+      }).test(url.pathname)) {
+        return false;
+      }
+      return true;
+    }
+    function hasRemoteMatch(domains, remotePatterns, url) {
+      return domains.some((domain) => url.hostname === domain) || remotePatterns.some((p) => matchRemotePattern(p, url));
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/image-loader.js
+var require_image_loader = __commonJS({
+  "node_modules/next/dist/shared/lib/image-loader.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "default", {
+      enumerable: true,
+      get: function() {
+        return _default;
+      }
+    });
+    var DEFAULT_Q = 75;
+    function defaultLoader(param) {
+      let { config, src, width, quality } = param;
+      var _config_qualities;
+      if (process.env.NODE_ENV !== "production") {
+        const missingValues = [];
+        if (!src) missingValues.push("src");
+        if (!width) missingValues.push("width");
+        if (missingValues.length > 0) {
+          throw Object.defineProperty(new Error("Next Image Optimization requires " + missingValues.join(", ") + " to be provided. Make sure you pass them as props to the `next/image` component. Received: " + JSON.stringify({
+            src,
+            width,
+            quality
+          })), "__NEXT_ERROR_CODE", {
+            value: "E188",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (src.startsWith("//")) {
+          throw Object.defineProperty(new Error('Failed to parse src "' + src + '" on `next/image`, protocol-relative URL (//) must be changed to an absolute URL (http:// or https://)'), "__NEXT_ERROR_CODE", {
+            value: "E360",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (src.startsWith("/") && config.localPatterns) {
+          if (process.env.NODE_ENV !== "test" && // micromatch isn't compatible with edge runtime
+          process.env.NEXT_RUNTIME !== "edge") {
+            const { hasLocalMatch } = require_match_local_pattern();
+            if (!hasLocalMatch(config.localPatterns, src)) {
+              throw Object.defineProperty(new Error("Invalid src prop (" + src + ") on `next/image` does not match `images.localPatterns` configured in your `next.config.js`\nSee more info: https://nextjs.org/docs/messages/next-image-unconfigured-localpatterns"), "__NEXT_ERROR_CODE", {
+                value: "E426",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          }
+        }
+        if (!src.startsWith("/") && (config.domains || config.remotePatterns)) {
+          let parsedSrc;
+          try {
+            parsedSrc = new URL(src);
+          } catch (err) {
+            console.error(err);
+            throw Object.defineProperty(new Error('Failed to parse src "' + src + '" on `next/image`, if using relative image it must start with a leading slash "/" or be an absolute URL (http:// or https://)'), "__NEXT_ERROR_CODE", {
+              value: "E63",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          if (process.env.NODE_ENV !== "test" && // micromatch isn't compatible with edge runtime
+          process.env.NEXT_RUNTIME !== "edge") {
+            const { hasRemoteMatch } = require_match_remote_pattern();
+            if (!hasRemoteMatch(config.domains, config.remotePatterns, parsedSrc)) {
+              throw Object.defineProperty(new Error("Invalid src prop (" + src + ') on `next/image`, hostname "' + parsedSrc.hostname + '" is not configured under images in your `next.config.js`\nSee more info: https://nextjs.org/docs/messages/next-image-unconfigured-host'), "__NEXT_ERROR_CODE", {
+                value: "E231",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          }
+        }
+        if (quality && config.qualities && !config.qualities.includes(quality)) {
+          throw Object.defineProperty(new Error("Invalid quality prop (" + quality + ") on `next/image` does not match `images.qualities` configured in your `next.config.js`\nSee more info: https://nextjs.org/docs/messages/next-image-unconfigured-qualities"), "__NEXT_ERROR_CODE", {
+            value: "E623",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      }
+      const q = quality || ((_config_qualities = config.qualities) == null ? void 0 : _config_qualities.reduce((prev, cur) => Math.abs(cur - DEFAULT_Q) < Math.abs(prev - DEFAULT_Q) ? cur : prev)) || DEFAULT_Q;
+      return config.path + "?url=" + encodeURIComponent(src) + "&w=" + width + "&q=" + q + (src.startsWith("/_next/static/media/") && process.env.NEXT_DEPLOYMENT_ID ? "&dpl=" + process.env.NEXT_DEPLOYMENT_ID : "");
+    }
+    defaultLoader.__next_img_default = true;
+    var _default = defaultLoader;
+  }
+});
+
+// node_modules/next/dist/client/use-merged-ref.js
+var require_use_merged_ref = __commonJS({
+  "node_modules/next/dist/client/use-merged-ref.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "useMergedRef", {
+      enumerable: true,
+      get: function() {
+        return useMergedRef;
+      }
+    });
+    var _react = require("react");
+    function useMergedRef(refA, refB) {
+      const cleanupA = (0, _react.useRef)(null);
+      const cleanupB = (0, _react.useRef)(null);
+      return (0, _react.useCallback)((current) => {
+        if (current === null) {
+          const cleanupFnA = cleanupA.current;
+          if (cleanupFnA) {
+            cleanupA.current = null;
+            cleanupFnA();
+          }
+          const cleanupFnB = cleanupB.current;
+          if (cleanupFnB) {
+            cleanupB.current = null;
+            cleanupFnB();
+          }
+        } else {
+          if (refA) {
+            cleanupA.current = applyRef(refA, current);
+          }
+          if (refB) {
+            cleanupB.current = applyRef(refB, current);
+          }
+        }
+      }, [
+        refA,
+        refB
+      ]);
     }
-    function _interop_require_wildcard(obj, nodeInterop) {
-      if (!nodeInterop && obj && obj.__esModule) return obj;
-      if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
-      var cache = _getRequireWildcardCache(nodeInterop);
-      if (cache && cache.has(obj)) return cache.get(obj);
-      var newObj = { __proto__: null };
-      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-      for (var key in obj) {
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-          if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
-          else newObj[key] = obj[key];
+    function applyRef(refA, current) {
+      if (typeof refA === "function") {
+        const cleanup = refA(current);
+        if (typeof cleanup === "function") {
+          return cleanup;
+        } else {
+          return () => refA(null);
         }
+      } else {
+        refA.current = current;
+        return () => {
+          refA.current = null;
+        };
       }
-      newObj.default = obj;
-      if (cache) cache.set(obj, newObj);
-      return newObj;
     }
-    exports2._ = _interop_require_wildcard;
+    if ((typeof exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/image-component.js
+var require_image_component = __commonJS({
+  "node_modules/next/dist/client/image-component.js"(exports2, module2) {
+    "use client";
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "Image", {
+      enumerable: true,
+      get: function() {
+        return Image3;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _interop_require_wildcard = require_interop_require_wildcard();
+    var _jsxruntime = require("react/jsx-runtime");
+    var _react = /* @__PURE__ */ _interop_require_wildcard._(require("react"));
+    var _reactdom = /* @__PURE__ */ _interop_require_default._(require("react-dom"));
+    var _head = /* @__PURE__ */ _interop_require_default._(require_head());
+    var _getimgprops = require_get_img_props();
+    var _imageconfig = require_image_config();
+    var _imageconfigcontextsharedruntime = require_image_config_context_shared_runtime();
+    var _warnonce = require_warn_once();
+    var _routercontextsharedruntime = require_router_context_shared_runtime();
+    var _imageloader = /* @__PURE__ */ _interop_require_default._(require_image_loader());
+    var _usemergedref = require_use_merged_ref();
+    var configEnv = process.env.__NEXT_IMAGE_OPTS;
+    if (typeof window === "undefined") {
+      ;
+      globalThis.__NEXT_IMAGE_IMPORTED = true;
+    }
+    function handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput) {
+      const src = img == null ? void 0 : img.src;
+      if (!img || img["data-loaded-src"] === src) {
+        return;
+      }
+      img["data-loaded-src"] = src;
+      const p = "decode" in img ? img.decode() : Promise.resolve();
+      p.catch(() => {
+      }).then(() => {
+        if (!img.parentElement || !img.isConnected) {
+          return;
+        }
+        if (placeholder !== "empty") {
+          setBlurComplete(true);
+        }
+        if (onLoadRef == null ? void 0 : onLoadRef.current) {
+          const event = new Event("load");
+          Object.defineProperty(event, "target", {
+            writable: false,
+            value: img
+          });
+          let prevented = false;
+          let stopped = false;
+          onLoadRef.current({
+            ...event,
+            nativeEvent: event,
+            currentTarget: img,
+            target: img,
+            isDefaultPrevented: () => prevented,
+            isPropagationStopped: () => stopped,
+            persist: () => {
+            },
+            preventDefault: () => {
+              prevented = true;
+              event.preventDefault();
+            },
+            stopPropagation: () => {
+              stopped = true;
+              event.stopPropagation();
+            }
+          });
+        }
+        if (onLoadingCompleteRef == null ? void 0 : onLoadingCompleteRef.current) {
+          onLoadingCompleteRef.current(img);
+        }
+        if (process.env.NODE_ENV !== "production") {
+          const origSrc = new URL(src, "http://n").searchParams.get("url") || src;
+          if (img.getAttribute("data-nimg") === "fill") {
+            if (!unoptimized && (!sizesInput || sizesInput === "100vw")) {
+              let widthViewportRatio = img.getBoundingClientRect().width / window.innerWidth;
+              if (widthViewportRatio < 0.6) {
+                if (sizesInput === "100vw") {
+                  (0, _warnonce.warnOnce)('Image with src "' + origSrc + '" has "fill" prop and "sizes" prop of "100vw", but image is not rendered at full viewport width. Please adjust "sizes" to improve page performance. Read more: https://nextjs.org/docs/api-reference/next/image#sizes');
+                } else {
+                  (0, _warnonce.warnOnce)('Image with src "' + origSrc + '" has "fill" but is missing "sizes" prop. Please add it to improve page performance. Read more: https://nextjs.org/docs/api-reference/next/image#sizes');
+                }
+              }
+            }
+            if (img.parentElement) {
+              const { position } = window.getComputedStyle(img.parentElement);
+              const valid = [
+                "absolute",
+                "fixed",
+                "relative"
+              ];
+              if (!valid.includes(position)) {
+                (0, _warnonce.warnOnce)('Image with src "' + origSrc + '" has "fill" and parent element with invalid "position". Provided "' + position + '" should be one of ' + valid.map(String).join(",") + ".");
+              }
+            }
+            if (img.height === 0) {
+              (0, _warnonce.warnOnce)('Image with src "' + origSrc + '" has "fill" and a height value of 0. This is likely because the parent element of the image has not been styled to have a set height.');
+            }
+          }
+          const heightModified = img.height.toString() !== img.getAttribute("height");
+          const widthModified = img.width.toString() !== img.getAttribute("width");
+          if (heightModified && !widthModified || !heightModified && widthModified) {
+            (0, _warnonce.warnOnce)('Image with src "' + origSrc + `" has either width or height modified, but not the other. If you use CSS to change the size of your image, also include the styles 'width: "auto"' or 'height: "auto"' to maintain the aspect ratio.`);
+          }
+        }
+      });
+    }
+    function getDynamicProps(fetchPriority) {
+      if (Boolean(_react.use)) {
+        return {
+          fetchPriority
+        };
+      }
+      return {
+        fetchpriority: fetchPriority
+      };
+    }
+    var ImageElement = /* @__PURE__ */ (0, _react.forwardRef)((param, forwardedRef) => {
+      let { src, srcSet, sizes, height, width, decoding, className, style, fetchPriority, placeholder, loading, unoptimized, fill, onLoadRef, onLoadingCompleteRef, setBlurComplete, setShowAltText, sizesInput, onLoad, onError, ...rest } = param;
+      const ownRef = (0, _react.useCallback)((img) => {
+        if (!img) {
+          return;
+        }
+        if (onError) {
+          img.src = img.src;
+        }
+        if (process.env.NODE_ENV !== "production") {
+          if (!src) {
+            console.error('Image is missing required "src" property:', img);
+          }
+          if (img.getAttribute("alt") === null) {
+            console.error('Image is missing required "alt" property. Please add Alternative Text to describe the image for screen readers and search engines.');
+          }
+        }
+        if (img.complete) {
+          handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput);
+        }
+      }, [
+        src,
+        placeholder,
+        onLoadRef,
+        onLoadingCompleteRef,
+        setBlurComplete,
+        onError,
+        unoptimized,
+        sizesInput
+      ]);
+      const ref = (0, _usemergedref.useMergedRef)(forwardedRef, ownRef);
+      return /* @__PURE__ */ (0, _jsxruntime.jsx)("img", {
+        ...rest,
+        ...getDynamicProps(fetchPriority),
+        // It's intended to keep `loading` before `src` because React updates
+        // props in order which causes Safari/Firefox to not lazy load properly.
+        // See https://github.com/facebook/react/issues/25883
+        loading,
+        width,
+        height,
+        decoding,
+        "data-nimg": fill ? "fill" : "1",
+        className,
+        style,
+        // It's intended to keep `src` the last attribute because React updates
+        // attributes in order. If we keep `src` the first one, Safari will
+        // immediately start to fetch `src`, before `sizes` and `srcSet` are even
+        // updated by React. That causes multiple unnecessary requests if `srcSet`
+        // and `sizes` are defined.
+        // This bug cannot be reproduced in Chrome or Firefox.
+        sizes,
+        srcSet,
+        src,
+        ref,
+        onLoad: (event) => {
+          const img = event.currentTarget;
+          handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput);
+        },
+        onError: (event) => {
+          setShowAltText(true);
+          if (placeholder !== "empty") {
+            setBlurComplete(true);
+          }
+          if (onError) {
+            onError(event);
+          }
+        }
+      });
+    });
+    function ImagePreload(param) {
+      let { isAppRouter, imgAttributes } = param;
+      const opts = {
+        as: "image",
+        imageSrcSet: imgAttributes.srcSet,
+        imageSizes: imgAttributes.sizes,
+        crossOrigin: imgAttributes.crossOrigin,
+        referrerPolicy: imgAttributes.referrerPolicy,
+        ...getDynamicProps(imgAttributes.fetchPriority)
+      };
+      if (isAppRouter && _reactdom.default.preload) {
+        _reactdom.default.preload(
+          imgAttributes.src,
+          // @ts-expect-error TODO: upgrade to `@types/react-dom@18.3.x`
+          opts
+        );
+        return null;
+      }
+      return /* @__PURE__ */ (0, _jsxruntime.jsx)(_head.default, {
+        children: /* @__PURE__ */ (0, _jsxruntime.jsx)("link", {
+          rel: "preload",
+          // Note how we omit the `href` attribute, as it would only be relevant
+          // for browsers that do not support `imagesrcset`, and in those cases
+          // it would cause the incorrect image to be preloaded.
+          //
+          // https://html.spec.whatwg.org/multipage/semantics.html#attr-link-imagesrcset
+          href: imgAttributes.srcSet ? void 0 : imgAttributes.src,
+          ...opts
+        }, "__nimg-" + imgAttributes.src + imgAttributes.srcSet + imgAttributes.sizes)
+      });
+    }
+    var Image3 = /* @__PURE__ */ (0, _react.forwardRef)((props, forwardedRef) => {
+      const pagesRouter = (0, _react.useContext)(_routercontextsharedruntime.RouterContext);
+      const isAppRouter = !pagesRouter;
+      const configContext = (0, _react.useContext)(_imageconfigcontextsharedruntime.ImageConfigContext);
+      const config = (0, _react.useMemo)(() => {
+        var _c_qualities;
+        const c = configEnv || configContext || _imageconfig.imageConfigDefault;
+        const allSizes = [
+          ...c.deviceSizes,
+          ...c.imageSizes
+        ].sort((a, b) => a - b);
+        const deviceSizes = c.deviceSizes.sort((a, b) => a - b);
+        const qualities = (_c_qualities = c.qualities) == null ? void 0 : _c_qualities.sort((a, b) => a - b);
+        return {
+          ...c,
+          allSizes,
+          deviceSizes,
+          qualities
+        };
+      }, [
+        configContext
+      ]);
+      const { onLoad, onLoadingComplete } = props;
+      const onLoadRef = (0, _react.useRef)(onLoad);
+      (0, _react.useEffect)(() => {
+        onLoadRef.current = onLoad;
+      }, [
+        onLoad
+      ]);
+      const onLoadingCompleteRef = (0, _react.useRef)(onLoadingComplete);
+      (0, _react.useEffect)(() => {
+        onLoadingCompleteRef.current = onLoadingComplete;
+      }, [
+        onLoadingComplete
+      ]);
+      const [blurComplete, setBlurComplete] = (0, _react.useState)(false);
+      const [showAltText, setShowAltText] = (0, _react.useState)(false);
+      const { props: imgAttributes, meta: imgMeta } = (0, _getimgprops.getImgProps)(props, {
+        defaultLoader: _imageloader.default,
+        imgConf: config,
+        blurComplete,
+        showAltText
+      });
+      return /* @__PURE__ */ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+          /* @__PURE__ */ (0, _jsxruntime.jsx)(ImageElement, {
+            ...imgAttributes,
+            unoptimized: imgMeta.unoptimized,
+            placeholder: imgMeta.placeholder,
+            fill: imgMeta.fill,
+            onLoadRef,
+            onLoadingCompleteRef,
+            setBlurComplete,
+            setShowAltText,
+            sizesInput: props.sizes,
+            ref: forwardedRef
+          }),
+          imgMeta.priority ? /* @__PURE__ */ (0, _jsxruntime.jsx)(ImagePreload, {
+            isAppRouter,
+            imgAttributes
+          }) : null
+        ]
+      });
+    });
+    if ((typeof exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/image-external.js
+var require_image_external = __commonJS({
+  "node_modules/next/dist/shared/lib/image-external.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      default: function() {
+        return _default;
+      },
+      getImageProps: function() {
+        return getImageProps;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _getimgprops = require_get_img_props();
+    var _imagecomponent = require_image_component();
+    var _imageloader = /* @__PURE__ */ _interop_require_default._(require_image_loader());
+    function getImageProps(imgProps) {
+      const { props } = (0, _getimgprops.getImgProps)(imgProps, {
+        defaultLoader: _imageloader.default,
+        // This is replaced by webpack define plugin
+        imgConf: process.env.__NEXT_IMAGE_OPTS
+      });
+      for (const [key, value] of Object.entries(props)) {
+        if (value === void 0) {
+          delete props[key];
+        }
+      }
+      return {
+        props
+      };
+    }
+    var _default = _imagecomponent.Image;
+  }
+});
+
+// node_modules/next/image.js
+var require_image = __commonJS({
+  "node_modules/next/image.js"(exports2, module2) {
+    module2.exports = require_image_external();
   }
 });
 
@@ -1943,42 +4806,9 @@ var require_add_locale2 = __commonJS({
       return path;
     };
     if ((typeof exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
-      Object.defineProperty(exports2.default, "__esModule", { value: true });
-      Object.assign(exports2.default, exports2);
-      module2.exports = exports2.default;
-    }
-  }
-});
-
-// node_modules/@swc/helpers/cjs/_interop_require_default.cjs
-var require_interop_require_default = __commonJS({
-  "node_modules/@swc/helpers/cjs/_interop_require_default.cjs"(exports2) {
-    "use strict";
-    function _interop_require_default(obj) {
-      return obj && obj.__esModule ? obj : { default: obj };
-    }
-    exports2._ = _interop_require_default;
-  }
-});
-
-// node_modules/next/dist/shared/lib/router-context.shared-runtime.js
-var require_router_context_shared_runtime = __commonJS({
-  "node_modules/next/dist/shared/lib/router-context.shared-runtime.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    Object.defineProperty(exports2, "RouterContext", {
-      enumerable: true,
-      get: function() {
-        return RouterContext;
-      }
-    });
-    var _interop_require_default = require_interop_require_default();
-    var _react = /* @__PURE__ */ _interop_require_default._(require("react"));
-    var RouterContext = _react.default.createContext(null);
-    if (process.env.NODE_ENV !== "production") {
-      RouterContext.displayName = "RouterContext";
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
     }
   }
 });
@@ -2339,71 +5169,6 @@ var require_add_base_path = __commonJS({
   }
 });
 
-// node_modules/next/dist/client/use-merged-ref.js
-var require_use_merged_ref = __commonJS({
-  "node_modules/next/dist/client/use-merged-ref.js"(exports2, module2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    Object.defineProperty(exports2, "useMergedRef", {
-      enumerable: true,
-      get: function() {
-        return useMergedRef;
-      }
-    });
-    var _react = require("react");
-    function useMergedRef(refA, refB) {
-      const cleanupA = (0, _react.useRef)(null);
-      const cleanupB = (0, _react.useRef)(null);
-      return (0, _react.useCallback)((current) => {
-        if (current === null) {
-          const cleanupFnA = cleanupA.current;
-          if (cleanupFnA) {
-            cleanupA.current = null;
-            cleanupFnA();
-          }
-          const cleanupFnB = cleanupB.current;
-          if (cleanupFnB) {
-            cleanupB.current = null;
-            cleanupFnB();
-          }
-        } else {
-          if (refA) {
-            cleanupA.current = applyRef(refA, current);
-          }
-          if (refB) {
-            cleanupB.current = applyRef(refB, current);
-          }
-        }
-      }, [
-        refA,
-        refB
-      ]);
-    }
-    function applyRef(refA, current) {
-      if (typeof refA === "function") {
-        const cleanup = refA(current);
-        if (typeof cleanup === "function") {
-          return cleanup;
-        } else {
-          return () => refA(null);
-        }
-      } else {
-        refA.current = current;
-        return () => {
-          refA.current = null;
-        };
-      }
-    }
-    if ((typeof exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
-      Object.defineProperty(exports2.default, "__esModule", { value: true });
-      Object.assign(exports2.default, exports2);
-      module2.exports = exports2.default;
-    }
-  }
-});
-
 // node_modules/next/dist/shared/lib/utils/error-once.js
 var require_error_once = __commonJS({
   "node_modules/next/dist/shared/lib/utils/error-once.js"(exports2) {
@@ -2890,6 +5655,7 @@ __export(index_exports, {
   LanguageModal: () => LanguageModal,
   LanguageProvider: () => LanguageProvider,
   LanguageUtil: () => LanguageUtil,
+  ListTile: () => ListTile,
   LoadingAndErrorComponent: () => LoadingAndErrorComponent,
   LoadingAnimation: () => LoadingAnimation,
   LoadingButton: () => LoadingButton,
@@ -2919,7 +5685,6 @@ __export(index_exports, {
   SearchBar: () => SearchBar,
   SearchableList: () => SearchableList,
   Select: () => Select,
-  SelectTile: () => SelectTile,
   SelectUncontrolled: () => SelectUncontrolled,
   SessionStorageService: () => SessionStorageService,
   SimpleSearch: () => SimpleSearch,
@@ -3060,14 +5825,16 @@ var import_lucide_react = require("lucide-react");
 var import_jsx_runtime = require("react/jsx-runtime");
 var Tile = ({
   title,
+  titleClassName,
   description,
+  descriptionClassName,
   onClick,
   isSelected = false,
   disabled = false,
   prefix,
   suffix,
   normalClassName = "hover:bg-primary/40 cursor-pointer",
-  selectedClassName = " bg-primary/20",
+  selectedClassName = "bg-primary/20",
   disabledClassName = "text-disabled-text bg-disabled-background cursor-not-allowed",
   className
 }) => {
@@ -3077,7 +5844,7 @@ var Tile = ({
       className: (0, import_clsx.default)(
         "flex-row-2 w-full items-center",
         {
-          [normalClassName]: !!onClick && !disabled,
+          [normalClassName]: onClick && !disabled,
           [selectedClassName]: isSelected && !disabled,
           [disabledClassName]: disabled
         },
@@ -3087,14 +5854,27 @@ var Tile = ({
       children: [
         prefix,
         /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex-col-0 w-full", children: [
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h4", { className: (0, import_clsx.default)(title.className ?? "textstyle-title-normal"), children: title.value }),
-          !!description && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: (0, import_clsx.default)(description.className ?? "textstyle-description"), children: description.value })
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: (0, import_clsx.default)(titleClassName ?? "textstyle-title-normal"), children: title }),
+          !!description && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: (0, import_clsx.default)(descriptionClassName ?? "textstyle-description"), children: description })
         ] }),
         suffix ?? (isSelected ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.Check, { size: 24 }) : void 0)
       ]
     }
   );
 };
+var ListTile = ({
+  ...props
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    Tile,
+    {
+      ...props,
+      titleClassName: props.titleClassName ?? "font-semibold",
+      className: (0, import_clsx.default)("px-2 py-1 rounded-md", props.className),
+      disabledClassName: props.disabledClassName ?? "text-disabled-text cursor-not-allowed"
+    }
+  );
+};
 
 // src/components/icons-and-geometry/Helpwave.tsx
 var import_clsx2 = require("clsx");
@@ -3180,7 +5960,8 @@ var HelpwaveBadge = ({
     Tile,
     {
       prefix: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Helpwave, { size: iconSize }),
-      title: { value: title, className: size === "small" ? "textstyle-title-lg text-base" : "textstyle-title-xl" },
+      title,
+      titleClassName: size === "small" ? "textstyle-title-lg text-base" : "textstyle-title-xl",
       className: (0, import_clsx3.default)(
         {
           "px-2 py-1 rounded-md": size === "small",
@@ -3258,9 +6039,6 @@ var useLocalStorage = (key, initValue) => {
     storageService.set(key, newValue);
     setStoredValue(newValue);
   }, [storedValue, setStoredValue, key]);
-  (0, import_react.useEffect)(() => {
-    setStoredValue(get());
-  }, []);
   return [storedValue, setValue];
 };
 
@@ -5035,35 +7813,10 @@ var ConfirmDialog = ({
 
 // src/components/icons-and-geometry/Avatar.tsx
 var import_clsx13 = __toESM(require("clsx"));
-
-// src/hooks/useLogOnce.ts
 var import_react11 = require("react");
-var useLogOnce = ({
-  message,
-  condition,
-  type = "warning"
-}) => {
-  const [hasLogged, setHasLogged] = (0, import_react11.useState)(false);
-  (0, import_react11.useEffect)(() => {
-    if (!hasLogged && condition) {
-      switch (type) {
-        case "info":
-          console.info(message);
-          break;
-        case "error":
-          console.error(message);
-          break;
-        case "warning":
-          console.warn(message);
-          break;
-      }
-      setHasLogged(true);
-    }
-  }, [condition]);
-};
-
-// src/components/icons-and-geometry/Avatar.tsx
 var import_react12 = require("react");
+var import_lucide_react5 = require("lucide-react");
+var import_image = __toESM(require_image());
 var import_jsx_runtime15 = require("react/jsx-runtime");
 var avtarSizeList = ["sm", "md", "lg", "xl"];
 var avatarSizeMapping = {
@@ -5084,6 +7837,7 @@ var AvatarUtil = {
 };
 var Avatar = ({ image, name, size = "md", fullyRounded, className = "" }) => {
   const pixels = avatarSizeMapping[size];
+  const [hasImageError, setHasImageError] = (0, import_react11.useState)(false);
   const sizeStyle = {
     minWidth: pixels,
     maxWidth: pixels,
@@ -5091,7 +7845,6 @@ var Avatar = ({ image, name, size = "md", fullyRounded, className = "" }) => {
     maxHeight: pixels
   };
   const textClassName = textClassNameMapping[size];
-  useLogOnce({ message: "Either set image or name in Avatar", condition: !image && !name, type: "warning" });
   const displayName = (0, import_react12.useMemo)(() => {
     const maxLetters = size === "sm" ? 1 : 2;
     return (name ?? "").split(" ").filter((_, index) => index < maxLetters).map((value) => value[0]).join("").toUpperCase();
@@ -5111,17 +7864,21 @@ var Avatar = ({ image, name, size = "md", fullyRounded, className = "" }) => {
       ),
       style: sizeStyle,
       children: [
-        name && !image && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: (0, import_clsx13.default)(textClassName, "absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2"), children: displayName }),
-        image && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
-          "img",
+        name && (!image || hasImageError) && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: (0, import_clsx13.default)(textClassName, "absolute z-[1] left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2"), children: displayName }),
+        !name && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: (0, import_clsx13.default)("absolute z-[1] left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2"), children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_lucide_react5.UserIcon, { size: Math.round(pixels * 3 / 4) }) }),
+        image && !hasImageError && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          import_image.default,
           {
             className: (0, import_clsx13.default)(
-              "absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2",
+              "absolute z-[2] left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2",
               rounding
             ),
             src: image.avatarUrl,
             alt: image.alt,
-            style: sizeStyle
+            style: sizeStyle,
+            width: pixels,
+            height: pixels,
+            onError: () => setHasImageError(true)
           }
         )
       ]
@@ -5460,13 +8217,14 @@ var RadialRings = ({
 };
 
 // src/components/icons-and-geometry/Tag.tsx
+var import_image2 = __toESM(require_image());
 var import_jsx_runtime18 = require("react/jsx-runtime");
 var TagIcon = ({
   className,
   size = 16
 }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
-    "img",
+    import_image2.default,
     {
       style: { width: `${size}px`, height: `${size}px`, minWidth: `${size}px`, minHeight: `${size}px` },
       width: size,
@@ -5481,26 +8239,30 @@ var TagIcon = ({
 // src/components/layout-and-navigation/BreadCrumb.tsx
 var import_link = __toESM(require_link2());
 var import_clsx16 = __toESM(require("clsx"));
+var import_react14 = require("react");
 var import_jsx_runtime19 = require("react/jsx-runtime");
 var BreadCrumb = ({ crumbs, linkClassName, containerClassName }) => {
   const color = "text-description";
-  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: (0, import_clsx16.default)("flex-row-0", containerClassName), children: crumbs.map((crumb, index) => /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
-      import_link.default,
-      {
-        href: crumb.link,
-        className: (0, import_clsx16.default)(linkClassName, { [`${color} hover:brightness-60`]: index !== crumbs.length - 1 }),
-        children: crumb.display
-      }
-    ),
-    index !== crumbs.length - 1 && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: (0, import_clsx16.default)(`px-1`, color), children: "/" })
-  ] }, index)) });
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: (0, import_clsx16.default)("flex-row-0.5 items-center", containerClassName), children: crumbs.map((crumb, index) => {
+    const isLast = index === crumbs.length - 1;
+    return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_react14.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+        import_link.default,
+        {
+          href: crumb.link,
+          className: (0, import_clsx16.default)("btn-sm hover:bg-description/20", linkClassName, { [color]: !isLast }),
+          children: crumb.display
+        }
+      ),
+      !isLast && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: (0, import_clsx16.default)(`px-1`, color), children: "/" })
+    ] }, index);
+  }) });
 };
 
 // src/components/layout-and-navigation/Carousel.tsx
-var import_react14 = require("react");
+var import_react15 = require("react");
 var import_clsx17 = __toESM(require("clsx"));
-var import_lucide_react5 = require("lucide-react");
+var import_lucide_react6 = require("lucide-react");
 
 // src/util/math.ts
 var clamp = (value, min = 0, max = 1) => {
@@ -5630,15 +8392,15 @@ var Carousel = ({
     currentPosition,
     dragState,
     animationState
-  }, setCarouselInformation] = (0, import_react14.useState)({
+  }, setCarouselInformation] = (0, import_react15.useState)({
     currentPosition: 0
   });
-  const animationId = (0, import_react14.useRef)(void 0);
-  const timeOut = (0, import_react14.useRef)(void 0);
+  const animationId = (0, import_react15.useRef)(void 0);
+  const timeOut = (0, import_react15.useRef)(void 0);
   autoLoopingTimeOut = Math.max(0, autoLoopingTimeOut);
   const length = children.length;
   const paddingItemCount = 3;
-  const util = (0, import_react14.useMemo)(() => new LoopingArrayCalculator(length, isLooping, overScrollThreshold), [length, isLooping, overScrollThreshold]);
+  const util = (0, import_react15.useMemo)(() => new LoopingArrayCalculator(length, isLooping, overScrollThreshold), [length, isLooping, overScrollThreshold]);
   const currentIndex = util.getCorrectedPosition(LoopingArrayCalculator.withoutOffset(currentPosition));
   animationTime = Math.max(200, animationTime);
   autoLoopAnimationTime = Math.max(200, autoLoopAnimationTime);
@@ -5646,7 +8408,7 @@ var Carousel = ({
     const baseOffset = -50 + (index - currentPosition) * 100;
     return `${baseOffset}%`;
   };
-  const animation = (0, import_react14.useCallback)((time) => {
+  const animation = (0, import_react15.useCallback)((time) => {
     let keepAnimating = true;
     setCarouselInformation((state) => {
       const {
@@ -5691,7 +8453,7 @@ var Carousel = ({
       animationId.current = requestAnimationFrame((time1) => animation(time1));
     }
   }, [animationTime, autoLoopAnimationTime, util]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (animationState) {
       animationId.current = requestAnimationFrame(animation);
     }
@@ -5713,7 +8475,7 @@ var Carousel = ({
       isAutoLooping: true
     }
   }));
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (!animationId.current && !animationState && !dragState && !timeOut.current) {
       if (autoLoopingTimeOut > 0) {
         timeOut.current = setTimeout(() => {
@@ -5855,7 +8617,7 @@ var Carousel = ({
             className: (0, import_clsx17.default)("absolute z-10 left-0 top-1/2 -translate-y-1/2 shadow-md", { hidden: !canGoLeft() }),
             disabled: !canGoLeft(),
             onClick: () => left(),
-            children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_lucide_react5.ChevronLeft, { size: 24 })
+            children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_lucide_react6.ChevronLeft, { size: 24 })
           }
         ),
         /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
@@ -5865,7 +8627,7 @@ var Carousel = ({
             className: (0, import_clsx17.default)("absolute z-10 right-0 top-1/2 -translate-y-1/2 shadow-md", { hidden: !canGoRight() }),
             disabled: !canGoRight(),
             onClick: () => right(),
-            children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_lucide_react5.ChevronRight, { size: 24 })
+            children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_lucide_react6.ChevronRight, { size: 24 })
           }
         )
       ] }),
@@ -5956,7 +8718,7 @@ var Chip = ({
     {
       ...restProps,
       className: (0, import_clsx18.default)(
-        `row w-fit px-2 py-1`,
+        `row w-fit px-2 py-1 font-semibold`,
         colorMapping,
         {
           "rounded-md": variant === "normal",
@@ -5979,7 +8741,7 @@ var ChipList = ({
     Chip,
     {
       ...value,
-      color: value.color ?? "dark",
+      color: value.color ?? "default",
       variant: value.variant ?? "normal",
       children: value.children
     },
@@ -6264,21 +9026,21 @@ var FAQSection = ({
 };
 
 // src/components/layout-and-navigation/Pagination.tsx
-var import_lucide_react6 = require("lucide-react");
+var import_lucide_react7 = require("lucide-react");
 var import_clsx23 = __toESM(require("clsx"));
 
 // src/components/user-action/Input.tsx
-var import_react18 = require("react");
+var import_react19 = require("react");
 var import_clsx22 = __toESM(require("clsx"));
 
 // src/hooks/useDelay.ts
-var import_react15 = require("react");
+var import_react16 = require("react");
 var defaultOptions = {
   delay: 3e3,
   disabled: false
 };
 function useDelay(options) {
-  const [timer, setTimer] = (0, import_react15.useState)(void 0);
+  const [timer, setTimer] = (0, import_react16.useState)(void 0);
   const { delay, disabled } = {
     ...defaultOptions,
     ...options
@@ -6297,12 +9059,12 @@ function useDelay(options) {
       setTimer(void 0);
     }, delay));
   };
-  (0, import_react15.useEffect)(() => {
+  (0, import_react16.useEffect)(() => {
     return () => {
       clearTimeout(timer);
     };
   }, [timer]);
-  (0, import_react15.useEffect)(() => {
+  (0, import_react16.useEffect)(() => {
     if (disabled) {
       clearTimeout(timer);
       setTimer(void 0);
@@ -6330,9 +9092,9 @@ var Label = ({
 };
 
 // src/hooks/useFocusManagement.ts
-var import_react16 = require("react");
+var import_react17 = require("react");
 function useFocusManagement() {
-  const getFocusableElements = (0, import_react16.useCallback)(() => {
+  const getFocusableElements = (0, import_react17.useCallback)(() => {
     return Array.from(
       document.querySelectorAll(
         'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"])'
@@ -6341,7 +9103,7 @@ function useFocusManagement() {
       (el) => el instanceof HTMLElement && !el.hasAttribute("disabled") && !el.hasAttribute("hidden") && el.tabIndex !== -1
     );
   }, []);
-  const getNextFocusElement = (0, import_react16.useCallback)(() => {
+  const getNextFocusElement = (0, import_react17.useCallback)(() => {
     const elements = getFocusableElements();
     if (elements.length === 0) {
       return void 0;
@@ -6353,11 +9115,11 @@ function useFocusManagement() {
     }
     return nextElement;
   }, [getFocusableElements]);
-  const focusNext = (0, import_react16.useCallback)(() => {
+  const focusNext = (0, import_react17.useCallback)(() => {
     const nextElement = getNextFocusElement();
     nextElement?.focus();
   }, [getNextFocusElement]);
-  const getPreviousFocusElement = (0, import_react16.useCallback)(() => {
+  const getPreviousFocusElement = (0, import_react17.useCallback)(() => {
     const elements = getFocusableElements();
     if (elements.length === 0) {
       return void 0;
@@ -6373,7 +9135,7 @@ function useFocusManagement() {
     }
     return previousElement;
   }, [getFocusableElements]);
-  const focusPrevious = (0, import_react16.useCallback)(() => {
+  const focusPrevious = (0, import_react17.useCallback)(() => {
     const previousElement = getPreviousFocusElement();
     if (previousElement) previousElement.focus();
   }, [getPreviousFocusElement]);
@@ -6387,10 +9149,10 @@ function useFocusManagement() {
 }
 
 // src/hooks/useFocusOnceVisible.ts
-var import_react17 = __toESM(require("react"));
+var import_react18 = __toESM(require("react"));
 var useFocusOnceVisible = (ref, disable = false) => {
-  const [hasUsedFocus, setHasUsedFocus] = import_react17.default.useState(false);
-  (0, import_react17.useEffect)(() => {
+  const [hasUsedFocus, setHasUsedFocus] = import_react18.default.useState(false);
+  (0, import_react18.useEffect)(() => {
     if (disable || hasUsedFocus) {
       return;
     }
@@ -6426,7 +9188,7 @@ var defaultEditCompleteOptions = {
   afterDelay: true,
   delay: 2500
 };
-var Input = (0, import_react18.forwardRef)(function Input2({
+var Input = (0, import_react19.forwardRef)(function Input2({
   id,
   type = "text",
   value,
@@ -6449,10 +9211,10 @@ var Input = (0, import_react18.forwardRef)(function Input2({
     restartTimer,
     clearTimer
   } = useDelay({ delay, disabled: !afterDelay });
-  const innerRef = (0, import_react18.useRef)(null);
+  const innerRef = (0, import_react19.useRef)(null);
   const { focusNext } = useFocusManagement();
   useFocusOnceVisible(innerRef, !autoFocus);
-  (0, import_react18.useImperativeHandle)(forwardedRef, () => innerRef.current);
+  (0, import_react19.useImperativeHandle)(forwardedRef, () => innerRef.current);
   const handleKeyDown = (e) => {
     if (e.key === "Enter" && !e.shiftKey) {
       e.preventDefault();
@@ -6506,8 +9268,8 @@ var InputUncontrolled = ({
   onChangeText = noop,
   ...props
 }) => {
-  const [usedValue, setUsedValue] = (0, import_react18.useState)(value);
-  (0, import_react18.useEffect)(() => {
+  const [usedValue, setUsedValue] = (0, import_react19.useState)(value);
+  (0, import_react19.useEffect)(() => {
     setUsedValue(value);
   }, [value]);
   return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
@@ -6522,7 +9284,7 @@ var InputUncontrolled = ({
     }
   );
 };
-var FormInput = (0, import_react18.forwardRef)(function FormInput2({
+var FormInput = (0, import_react19.forwardRef)(function FormInput2({
   id,
   labelText,
   errorText,
@@ -6558,7 +9320,7 @@ var FormInput = (0, import_react18.forwardRef)(function FormInput2({
 });
 
 // src/components/layout-and-navigation/Pagination.tsx
-var import_react19 = require("react");
+var import_react20 = require("react");
 var import_jsx_runtime27 = require("react/jsx-runtime");
 var Pagination = ({
   overwriteTranslation,
@@ -6569,11 +9331,11 @@ var Pagination = ({
   style
 }) => {
   const translation = useTranslation([formTranslation], overwriteTranslation);
-  const [value, setValue] = (0, import_react19.useState)((pageIndex + 1).toString());
+  const [value, setValue] = (0, import_react20.useState)((pageIndex + 1).toString());
   const noPages = pageCount === 0;
   const onFirstPage = pageIndex === 0 && !noPages;
   const onLastPage = pageIndex === pageCount - 1;
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     if (noPages) {
       setValue("0");
     } else {
@@ -6584,8 +9346,8 @@ var Pagination = ({
     onPageChanged(page);
   };
   return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("div", { className: (0, import_clsx23.default)("flex-row-1", className), style, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(0), disabled: onFirstPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react6.ChevronFirst, {}) }),
-    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageIndex - 1), disabled: onFirstPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react6.ChevronLeft, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(0), disabled: onFirstPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react7.ChevronFirst, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageIndex - 1), disabled: onFirstPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react7.ChevronLeft, {}) }),
     /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("div", { className: "flex-row-2 min-w-56 items-center justify-center mx-2 text-center", children: [
       /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
         Input,
@@ -6621,17 +9383,17 @@ var Pagination = ({
         }
       )
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageIndex + 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react6.ChevronRight, {}) }),
-    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageCount - 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react6.ChevronLast, {}) })
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageIndex + 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react7.ChevronRight, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageCount - 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_lucide_react7.ChevronLast, {}) })
   ] });
 };
 
 // src/components/layout-and-navigation/SearchableList.tsx
-var import_lucide_react7 = require("lucide-react");
+var import_lucide_react8 = require("lucide-react");
 var import_clsx24 = __toESM(require("clsx"));
 
 // src/hooks/useSearch.ts
-var import_react20 = require("react");
+var import_react21 = require("react");
 
 // src/util/simpleSearch.ts
 var MultiSubjectSearchWithMapping = (search, objects, mapping) => {
@@ -6670,34 +9432,34 @@ var useSearch = ({
   filter,
   disabled = false
 }) => {
-  const [search, setSearch] = (0, import_react20.useState)(initialSearch ?? "");
-  const [result, setResult] = (0, import_react20.useState)(list);
-  const searchTags = (0, import_react20.useMemo)(() => additionalSearchTags ?? [], [additionalSearchTags]);
-  const updateSearch = (0, import_react20.useCallback)((newSearch) => {
+  const [search, setSearch] = (0, import_react21.useState)(initialSearch ?? "");
+  const [result, setResult] = (0, import_react21.useState)(list);
+  const searchTags = (0, import_react21.useMemo)(() => additionalSearchTags ?? [], [additionalSearchTags]);
+  const updateSearch = (0, import_react21.useCallback)((newSearch) => {
     const usedSearch = newSearch ?? search;
     if (newSearch) {
       setSearch(search);
     }
     setResult(MultiSubjectSearchWithMapping([usedSearch, ...searchTags], list, searchMapping));
   }, [searchTags, list, search, searchMapping]);
-  (0, import_react20.useEffect)(() => {
+  (0, import_react21.useEffect)(() => {
     if (isSearchInstant) {
       setResult(MultiSubjectSearchWithMapping([search, ...searchTags], list, searchMapping));
     }
   }, [searchTags, isSearchInstant, list, search, searchMapping, additionalSearchTags]);
-  const filteredResult = (0, import_react20.useMemo)(() => {
+  const filteredResult = (0, import_react21.useMemo)(() => {
     if (!filter) {
       return result;
     }
     return result.filter(filter);
   }, [result, filter]);
-  const sortedAndFilteredResult = (0, import_react20.useMemo)(() => {
+  const sortedAndFilteredResult = (0, import_react21.useMemo)(() => {
     if (!sortingFunction) {
       return filteredResult;
     }
     return filteredResult.sort(sortingFunction);
   }, [filteredResult, sortingFunction]);
-  const usedResult = (0, import_react20.useMemo)(() => {
+  const usedResult = (0, import_react21.useMemo)(() => {
     if (!disabled) {
       return sortedAndFilteredResult;
     }
@@ -6748,16 +9510,16 @@ var SearchableList = ({
           className: "w-full"
         }
       ),
-      /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(IconButton, { color: "neutral", onClick: () => updateSearch(), children: /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(import_lucide_react7.Search, { className: "w-full h-full" }) })
+      /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(IconButton, { color: "neutral", onClick: () => updateSearch(), children: /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(import_lucide_react8.Search, { className: "w-full h-full" }) })
     ] }),
     hasResult ? /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("div", { className: (0, import_clsx24.default)("flex-col-1 overflow-y-auto", resultListClassName), children: result.map(itemMapper) }) : /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("div", { className: "flex-row-2 text-description py-2 px-2", children: translation("nothingFound") })
   ] });
 };
 
 // src/components/layout-and-navigation/StepperBar.tsx
-var import_lucide_react8 = require("lucide-react");
+var import_lucide_react9 = require("lucide-react");
 var import_clsx25 = __toESM(require("clsx"));
-var import_react21 = require("react");
+var import_react22 = require("react");
 var import_jsx_runtime29 = require("react/jsx-runtime");
 var defaultState = {
   currentStep: 0,
@@ -6795,7 +9557,7 @@ var StepperBar = ({
             },
             className: "flex-row-1 items-center justify-center",
             children: [
-              /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_lucide_react8.ChevronLeft, { size: 14 }),
+              /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_lucide_react9.ChevronLeft, { size: 14 }),
               translation("back")
             ]
           }
@@ -6830,7 +9592,7 @@ var StepperBar = ({
             disabled: disabledSteps.has(currentStep),
             children: [
               translation("next"),
-              /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_lucide_react8.ChevronRight, { size: 14 })
+              /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_lucide_react9.ChevronRight, { size: 14 })
             ]
           }
         ) }),
@@ -6841,7 +9603,7 @@ var StepperBar = ({
             onClick: onFinish,
             className: "flex-row-1 items-center justify-center",
             children: [
-              /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_lucide_react8.Check, { size: 14 }),
+              /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_lucide_react9.Check, { size: 14 }),
               finishText ?? translation("confirm")
             ]
           }
@@ -6851,8 +9613,8 @@ var StepperBar = ({
   );
 };
 var StepperBarUncontrolled = ({ state, onChange, ...props }) => {
-  const [usedState, setUsedState] = (0, import_react21.useState)(state ?? defaultState);
-  (0, import_react21.useEffect)(() => {
+  const [usedState, setUsedState] = (0, import_react22.useState)(state ?? defaultState);
+  (0, import_react22.useEffect)(() => {
     setUsedState(state ?? defaultState);
   }, [state]);
   return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(
@@ -6973,7 +9735,7 @@ var VerticalDivider = ({
 };
 
 // src/components/loading-states/ErrorComponent.tsx
-var import_lucide_react9 = require("lucide-react");
+var import_lucide_react10 = require("lucide-react");
 var import_clsx27 = __toESM(require("clsx"));
 var import_jsx_runtime32 = require("react/jsx-runtime");
 var defaultErrorComponentTranslation = {
@@ -6991,13 +9753,13 @@ var ErrorComponent = ({
 }) => {
   const translation = useTranslation([defaultErrorComponentTranslation], overwriteTranslation);
   return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("div", { className: (0, import_clsx27.default)("flex-col-4 items-center justify-center w-full h-24", classname), children: [
-    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_lucide_react9.AlertOctagon, { size: 64, className: "text-warning" }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_lucide_react10.AlertOctagon, { size: 64, className: "text-warning" }),
     errorText ?? `${translation("errorOccurred")} :(`
   ] });
 };
 
 // src/components/loading-states/LoadingAndErrorComponent.tsx
-var import_react22 = require("react");
+var import_react23 = require("react");
 
 // src/components/loading-states/LoadingContainer.tsx
 var import_clsx28 = require("clsx");
@@ -7015,11 +9777,11 @@ var LoadingAndErrorComponent = ({
   hasError = false,
   loadingComponent,
   errorComponent,
-  minimumLoadingDuration,
+  minimumLoadingDuration = 200,
   className
 }) => {
-  const [isInMinimumLoading, setIsInMinimumLoading] = (0, import_react22.useState)(false);
-  const [hasUsedMinimumLoading, setHasUsedMinimumLoading] = (0, import_react22.useState)(false);
+  const [isInMinimumLoading, setIsInMinimumLoading] = (0, import_react23.useState)(false);
+  const [hasUsedMinimumLoading, setHasUsedMinimumLoading] = (0, import_react23.useState)(false);
   if (minimumLoadingDuration && !isInMinimumLoading && !hasUsedMinimumLoading) {
     setIsInMinimumLoading(true);
     setTimeout(() => {
@@ -7222,18 +9984,18 @@ var InputModal = ({
 };
 
 // src/components/user-action/Select.tsx
-var import_react25 = require("react");
 var import_react26 = require("react");
+var import_react27 = require("react");
 var import_clsx35 = __toESM(require("clsx"));
 
 // src/components/user-action/Menu.tsx
-var import_react24 = require("react");
+var import_react25 = require("react");
 var import_clsx33 = __toESM(require("clsx"));
 
 // src/hooks/useOutsideClick.ts
-var import_react23 = require("react");
+var import_react24 = require("react");
 var useOutsideClick = (refs, handler) => {
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     const listener = (event) => {
       if (event.target === null) return;
       if (refs.some((ref) => !ref.current || ref.current.contains(event.target))) {
@@ -7357,10 +10119,10 @@ var Menu = ({
   menuClassName = ""
 }) => {
   const { isHovered: isOpen, setIsHovered: setIsOpen } = useHoverState({ isDisabled: !showOnHover || disabled });
-  const triggerRef = (0, import_react24.useRef)(null);
-  const menuRef = (0, import_react24.useRef)(null);
+  const triggerRef = (0, import_react25.useRef)(null);
+  const menuRef = (0, import_react25.useRef)(null);
   useOutsideClick([triggerRef, menuRef], () => setIsOpen(false));
-  const [isHidden, setIsHidden] = (0, import_react24.useState)(true);
+  const [isHidden, setIsHidden] = (0, import_react25.useState)(true);
   const bag = {
     isOpen,
     close: () => setIsOpen(false),
@@ -7371,7 +10133,7 @@ var Menu = ({
     triggerRef.current?.getBoundingClientRect(),
     { verticalAlignment: alignmentVertical, horizontalAlignment: alignmentHorizontal, disabled }
   );
-  (0, import_react24.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     if (!isOpen) return;
     const triggerEl = triggerRef.current;
     if (!triggerEl) return;
@@ -7388,7 +10150,7 @@ var Menu = ({
       window.removeEventListener("resize", close);
     };
   }, [isOpen, setIsOpen]);
-  (0, import_react24.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     if (isOpen) {
       setIsHidden(false);
     }
@@ -7424,7 +10186,7 @@ var Menu = ({
 };
 
 // src/components/user-action/SearchBar.tsx
-var import_lucide_react10 = require("lucide-react");
+var import_lucide_react11 = require("lucide-react");
 var import_clsx34 = require("clsx");
 var import_jsx_runtime42 = require("react/jsx-runtime");
 var SearchBar = ({
@@ -7443,28 +10205,12 @@ var SearchBar = ({
         placeholder: placeholder ?? translation("search")
       }
     ),
-    onSearch && /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(IconButton, { color: "neutral", disabled: disableOnSearch, onClick: onSearch, children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_lucide_react10.Search, { className: "w-full h-full" }) })
+    onSearch && /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(IconButton, { color: "neutral", disabled: disableOnSearch, onClick: onSearch, children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_lucide_react11.Search, { className: "w-full h-full" }) })
   ] });
 };
 
 // src/components/user-action/Select.tsx
 var import_jsx_runtime43 = require("react/jsx-runtime");
-var SelectTile = ({
-  className,
-  disabledClassName,
-  title,
-  ...restProps
-}) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(
-    Tile,
-    {
-      ...restProps,
-      className: (0, import_clsx35.default)("px-2 py-1 rounded-md", className),
-      disabledClassName: disabledClassName ?? "text-disabled-text cursor-not-allowed",
-      title: { ...title, className: title.className ?? "font-semibold" }
-    }
-  );
-};
 var Select = ({
   value,
   label,
@@ -7486,7 +10232,7 @@ var Select = ({
   const isShowingHint = !selectedDisplayOverwrite && !selectedOption?.label;
   const { result, search, setSearch } = useSearch({
     list: options,
-    searchMapping: (0, import_react25.useCallback)((item) => item.searchTags, []),
+    searchMapping: (0, import_react26.useCallback)((item) => item.searchTags, []),
     ...searchOptions
   });
   return /* @__PURE__ */ (0, import_jsx_runtime43.jsxs)("div", { className: (0, import_clsx35.default)(className), children: [
@@ -7531,10 +10277,10 @@ var Select = ({
             ),
             /* @__PURE__ */ (0, import_jsx_runtime43.jsxs)("div", { className: "flex-col-2 overflow-y-auto", children: [
               result.map((option, index) => /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(
-                SelectTile,
+                ListTile,
                 {
                   isSelected: option === selectedOption,
-                  title: { value: option.label },
+                  title: option.label,
                   onClick: () => {
                     onChange(option.value);
                     close();
@@ -7558,8 +10304,8 @@ var SelectUncontrolled = ({
   hintText,
   ...props
 }) => {
-  const [selected, setSelected] = (0, import_react26.useState)(value);
-  (0, import_react26.useEffect)(() => {
+  const [selected, setSelected] = (0, import_react27.useState)(value);
+  (0, import_react27.useEffect)(() => {
     if (options.find((options2) => options2.value === value)) {
       setSelected(value);
     }
@@ -7631,8 +10377,8 @@ var LanguageModal = ({
 };
 
 // src/theming/useTheme.tsx
-var import_react27 = require("react");
 var import_react28 = require("react");
+var import_react29 = require("react");
 var import_jsx_runtime45 = require("react/jsx-runtime");
 var themes = ["light", "dark", "system"];
 var defaultThemeTypeTranslation = {
@@ -7659,30 +10405,30 @@ var ThemeUtil = {
   themes,
   translation: defaultThemeTypeTranslation
 };
-var ThemeContext = (0, import_react28.createContext)({
+var ThemeContext = (0, import_react29.createContext)({
   theme: "light",
   setTheme: noop
 });
-var ThemeProvider = ({ children, initialTheme = "system" }) => {
-  const [storedTheme, setStoredTheme] = useLocalStorage("theme", initialTheme);
-  const [userTheme, setUserTheme] = (0, import_react28.useState)();
-  (0, import_react28.useEffect)(() => {
-    if (storedTheme !== initialTheme) {
+var ThemeProvider = ({ children, initialTheme }) => {
+  const [storedTheme, setStoredTheme] = useLocalStorage("theme", initialTheme ?? "system");
+  const [userTheme, setUserTheme] = (0, import_react29.useState)();
+  (0, import_react29.useEffect)(() => {
+    if (!!initialTheme && storedTheme !== initialTheme) {
       console.warn("ThemeProvider initial state changed: Prefer using useTheme's setTheme instead");
       setStoredTheme(initialTheme);
     }
   }, [initialTheme]);
-  const usedTheme = (0, import_react27.useMemo)(() => storedTheme !== "system" ? storedTheme : userTheme, [storedTheme, userTheme]);
-  (0, import_react28.useEffect)(() => {
+  const usedTheme = (0, import_react28.useMemo)(() => storedTheme !== "system" ? storedTheme : userTheme, [storedTheme, userTheme]);
+  (0, import_react29.useEffect)(() => {
     document.documentElement.setAttribute("data-theme", usedTheme);
   }, [usedTheme]);
-  (0, import_react28.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
     setUserTheme(prefersDark ? "dark" : "light");
   }, []);
-  return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(ThemeContext.Provider, { value: { theme: storedTheme, setTheme: setStoredTheme }, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(ThemeContext.Provider, { value: { theme: usedTheme, setTheme: setStoredTheme }, children });
 };
-var useTheme = () => (0, import_react28.useContext)(ThemeContext);
+var useTheme = () => (0, import_react29.useContext)(ThemeContext);
 
 // src/components/modals/ThemeModal.tsx
 var import_jsx_runtime46 = require("react/jsx-runtime");
@@ -7730,12 +10476,12 @@ var ThemeModal = ({
 };
 
 // src/components/properties/CheckboxProperty.tsx
-var import_lucide_react13 = require("lucide-react");
+var import_lucide_react14 = require("lucide-react");
 
 // src/components/user-action/Checkbox.tsx
-var import_react29 = require("react");
+var import_react30 = require("react");
 var CheckboxPrimitive = __toESM(require("@radix-ui/react-checkbox"));
-var import_lucide_react11 = require("lucide-react");
+var import_lucide_react12 = require("lucide-react");
 var import_clsx36 = __toESM(require("clsx"));
 var import_jsx_runtime47 = require("react/jsx-runtime");
 var checkboxSizeMapping = {
@@ -7788,8 +10534,8 @@ var Checkbox = ({
           "bg-primary/30 border-primary text-primary": !disabled && checked === true || checked === "indeterminate"
         }, className),
         children: /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)(CheckboxPrimitive.Indicator, { children: [
-          checked === true && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(import_lucide_react11.Check, { className: innerIconSize }),
-          checked === "indeterminate" && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(import_lucide_react11.Minus, { className: innerIconSize })
+          checked === true && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(import_lucide_react12.Check, { className: innerIconSize }),
+          checked === "indeterminate" && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(import_lucide_react12.Minus, { className: innerIconSize })
         ] })
       }
     ),
@@ -7802,7 +10548,7 @@ var CheckboxUncontrolled = ({
   defaultValue = false,
   ...props
 }) => {
-  const [checked, setChecked] = (0, import_react29.useState)(defaultValue);
+  const [checked, setChecked] = (0, import_react30.useState)(defaultValue);
   const handleChange = (checked2) => {
     if (onChangeTristate) {
       onChangeTristate(checked2);
@@ -7823,7 +10569,7 @@ var CheckboxUncontrolled = ({
 };
 
 // src/components/properties/PropertyBase.tsx
-var import_lucide_react12 = require("lucide-react");
+var import_lucide_react13 = require("lucide-react");
 var import_clsx37 = __toESM(require("clsx"));
 var import_jsx_runtime48 = require("react/jsx-runtime");
 var PropertyBase = ({
@@ -7852,7 +10598,7 @@ var PropertyBase = ({
           className
         ),
         children: [
-          /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("div", { className: "max-w-6 min-w-6 text-text-default", children: icon }),
+          /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("div", { className: "max-w-6 min-w-6 text-text-primary", children: icon }),
           /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("span", { className: "font-semibold", children: name })
         ]
       }
@@ -7870,7 +10616,7 @@ var PropertyBase = ({
         ),
         children: [
           input({ softRequired, hasValue }),
-          requiredAndNoValue && /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("div", { className: "text-warning", children: /* @__PURE__ */ (0, import_jsx_runtime48.jsx)(import_lucide_react12.AlertTriangle, { size: 24 }) }),
+          requiredAndNoValue && /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("div", { className: "text-warning", children: /* @__PURE__ */ (0, import_jsx_runtime48.jsx)(import_lucide_react13.AlertTriangle, { size: 24 }) }),
           onRemove && hasValue && /* @__PURE__ */ (0, import_jsx_runtime48.jsx)(
             TextButton,
             {
@@ -7903,7 +10649,7 @@ var CheckboxProperty = ({
       ...baseProps,
       hasValue: true,
       readOnly,
-      icon: /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(import_lucide_react13.Check, { size: 24 }),
+      icon: /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(import_lucide_react14.Check, { size: 24 }),
       input: () => /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
         Checkbox,
         {
@@ -7919,7 +10665,7 @@ var CheckboxProperty = ({
 };
 
 // src/components/properties/DateProperty.tsx
-var import_lucide_react14 = require("lucide-react");
+var import_lucide_react15 = require("lucide-react");
 var import_clsx38 = __toESM(require("clsx"));
 var import_jsx_runtime50 = require("react/jsx-runtime");
 var DateProperty = ({
@@ -7937,7 +10683,7 @@ var DateProperty = ({
     {
       ...baseProps,
       hasValue,
-      icon: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(import_lucide_react14.CalendarDays, { size: 24 }),
+      icon: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(import_lucide_react15.CalendarDays, { size: 24 }),
       input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
         Input,
         {
@@ -7962,14 +10708,14 @@ var DateProperty = ({
 };
 
 // src/components/properties/MultiSelectProperty.tsx
-var import_lucide_react16 = require("lucide-react");
+var import_lucide_react17 = require("lucide-react");
 var import_clsx40 = __toESM(require("clsx"));
 
 // src/components/user-action/MultiSelect.tsx
-var import_react30 = require("react");
 var import_react31 = require("react");
+var import_react32 = require("react");
 var import_clsx39 = __toESM(require("clsx"));
-var import_lucide_react15 = require("lucide-react");
+var import_lucide_react16 = require("lucide-react");
 var import_jsx_runtime51 = require("react/jsx-runtime");
 var defaultMultiSelectTranslation = {
   en: {
@@ -7997,7 +10743,7 @@ var MultiSelect = ({
   const translation = useTranslation([formTranslation, defaultMultiSelectTranslation], overwriteTranslation);
   const { result, search, setSearch } = useSearch({
     list: options,
-    searchMapping: (0, import_react30.useCallback)((item) => item.searchTags, []),
+    searchMapping: (0, import_react31.useCallback)((item) => item.searchTags, []),
     ...searchOptions
   });
   const selectedItems = options.filter((value) => value.selected);
@@ -8031,7 +10777,19 @@ var MultiSelect = ({
             ),
             onClick: toggleOpen,
             disabled,
-            children: useChipDisplay ? /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(import_jsx_runtime51.Fragment, { children: isShowingHint ? /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("div", { className: "icon-btn-sm bg-button-solid-neutral-background text-button-solid-neutral-text hover:brightness-90 group-hover:brightness-90", children: /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(import_lucide_react15.Plus, {}) }) : /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(ChipList, { list: selectedItems.map((value) => ({ children: value.label })) }) }) : /* @__PURE__ */ (0, import_jsx_runtime51.jsxs)(import_jsx_runtime51.Fragment, { children: [
+            children: useChipDisplay ? /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(import_jsx_runtime51.Fragment, { children: isShowingHint ? /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(
+              "div",
+              {
+                className: (0, import_clsx39.default)(
+                  "icon-btn-sm ",
+                  {
+                    "bg-button-solid-neutral-background text-button-solid-neutral-text hover:brightness-90 group-hover:brightness-90": !disabled,
+                    "bg-disabled-background text-disabled-text": disabled
+                  }
+                ),
+                children: /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(import_lucide_react16.Plus, {})
+              }
+            ) : /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(ChipList, { list: selectedItems.map((value) => ({ children: value.label })) }) }) : /* @__PURE__ */ (0, import_jsx_runtime51.jsxs)(import_jsx_runtime51.Fragment, { children: [
               !isShowingHint && /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("span", { className: "font-semibold", children: selectedDisplayOverwrite ?? translation("selected", { replacements: { amount: selectedItems.length.toString() } }) }),
               isShowingHint && /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("span", { className: (0, import_clsx39.default)("textstyle-description", hintTextClassName), children: hintText ?? translation("select") }),
               /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(ExpansionIcon, { isExpanded: isOpen })
@@ -8059,7 +10817,7 @@ var MultiSelect = ({
                   } : value));
                 };
                 return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(
-                  SelectTile,
+                  ListTile,
                   {
                     prefix: /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(
                       Checkbox,
@@ -8070,7 +10828,7 @@ var MultiSelect = ({
                         disabled: option.disabled
                       }
                     ),
-                    title: { value: option.label },
+                    title: option.label,
                     onClick: update,
                     disabled: option.disabled
                   },
@@ -8124,8 +10882,8 @@ var MultiSelectUncontrolled = ({
   onChange,
   ...props
 }) => {
-  const [usedOptions, setUsedOptions] = (0, import_react31.useState)(options);
-  (0, import_react31.useEffect)(() => {
+  const [usedOptions, setUsedOptions] = (0, import_react32.useState)(options);
+  (0, import_react32.useEffect)(() => {
     setUsedOptions(options);
   }, [options]);
   return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(
@@ -8163,7 +10921,7 @@ var MultiSelectProperty = ({
       readOnly,
       softRequired,
       hasValue,
-      icon: /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(import_lucide_react16.List, { size: 24 }),
+      icon: /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(import_lucide_react17.List, { size: 24 }),
       input: ({ softRequired: softRequired2 }) => /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(
         MultiSelect,
         {
@@ -8182,10 +10940,10 @@ var MultiSelectProperty = ({
               return void 0;
             }
             return /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(
-              SelectTile,
+              ListTile,
               {
-                prefix: /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(import_lucide_react16.Plus, {}),
-                title: { value: `${translation("add")} ${search.trim()}` },
+                prefix: /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(import_lucide_react17.Plus, {}),
+                title: `${translation("add")} ${search.trim()}`,
                 onClick: () => {
                   onAddNew(search);
                   close();
@@ -8208,7 +10966,7 @@ var MultiSelectProperty = ({
 };
 
 // src/components/properties/NumberProperty.tsx
-var import_lucide_react17 = require("lucide-react");
+var import_lucide_react18 = require("lucide-react");
 var import_clsx41 = __toESM(require("clsx"));
 var import_jsx_runtime53 = require("react/jsx-runtime");
 var defaultNumberPropertyTranslation = {
@@ -8237,7 +10995,7 @@ var NumberProperty = ({
       ...baseProps,
       onRemove,
       hasValue,
-      icon: /* @__PURE__ */ (0, import_jsx_runtime53.jsx)(import_lucide_react17.Binary, { size: 24 }),
+      icon: /* @__PURE__ */ (0, import_jsx_runtime53.jsx)(import_lucide_react18.Binary, { size: 24 }),
       input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime53.jsxs)(
         "div",
         {
@@ -8279,7 +11037,7 @@ var NumberProperty = ({
 };
 
 // src/components/properties/SelectProperty.tsx
-var import_lucide_react18 = require("lucide-react");
+var import_lucide_react19 = require("lucide-react");
 var import_clsx42 = __toESM(require("clsx"));
 var import_jsx_runtime54 = require("react/jsx-runtime");
 var SingleSelectProperty = ({
@@ -8303,7 +11061,7 @@ var SingleSelectProperty = ({
       readOnly,
       softRequired,
       hasValue,
-      icon: /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(import_lucide_react18.List, { size: 24 }),
+      icon: /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(import_lucide_react19.List, { size: 24 }),
       input: ({ softRequired: softRequired2 }) => /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(
         Select,
         {
@@ -8322,10 +11080,10 @@ var SingleSelectProperty = ({
               return void 0;
             }
             return /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(
-              SelectTile,
+              ListTile,
               {
-                prefix: /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(import_lucide_react18.Plus, {}),
-                title: { value: `${translation("add")} ${search.trim()}` },
+                prefix: /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(import_lucide_react19.Plus, {}),
+                title: `${translation("add")} ${search.trim()}`,
                 onClick: () => {
                   onAddNew(search);
                   close();
@@ -8349,11 +11107,11 @@ var SingleSelectProperty = ({
 };
 
 // src/components/properties/TextProperty.tsx
-var import_lucide_react19 = require("lucide-react");
+var import_lucide_react20 = require("lucide-react");
 var import_clsx44 = __toESM(require("clsx"));
 
 // src/components/user-action/Textarea.tsx
-var import_react32 = require("react");
+var import_react33 = require("react");
 var import_clsx43 = __toESM(require("clsx"));
 var import_jsx_runtime55 = require("react/jsx-runtime");
 var Textarea = ({
@@ -8372,7 +11130,7 @@ var Textarea = ({
   className,
   ...props
 }) => {
-  const [hasFocus, setHasFocus] = (0, import_react32.useState)(false);
+  const [hasFocus, setHasFocus] = (0, import_react33.useState)(false);
   const { restartTimer, clearTimer } = useDelay(saveDelayOptions);
   const onEditCompletedWrapper = (text) => {
     onEditCompleted(text);
@@ -8442,8 +11200,8 @@ var TextareaUncontrolled = ({
   onChangeText = noop,
   ...props
 }) => {
-  const [text, setText] = (0, import_react32.useState)(value);
-  (0, import_react32.useEffect)(() => {
+  const [text, setText] = (0, import_react33.useState)(value);
+  (0, import_react33.useEffect)(() => {
     setText(value);
   }, [value]);
   return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(
@@ -8486,7 +11244,7 @@ var TextProperty = ({
       ...baseProps,
       onRemove,
       hasValue,
-      icon: /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(import_lucide_react19.Text, { size: 24 }),
+      icon: /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(import_lucide_react20.Text, { size: 24 }),
       input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(
         Textarea,
         {
@@ -8540,14 +11298,14 @@ var TableFilters = {
 };
 
 // src/components/table/Table.tsx
-var import_react35 = require("react");
+var import_react36 = require("react");
 var import_clsx48 = __toESM(require("clsx"));
 var import_react_table = require("@tanstack/react-table");
 var import_react_custom_scrollbars_23 = require("react-custom-scrollbars-2");
 
 // src/components/table/TableFilterButton.tsx
-var import_lucide_react20 = require("lucide-react");
-var import_react33 = require("react");
+var import_lucide_react21 = require("lucide-react");
+var import_react34 = require("react");
 var import_jsx_runtime58 = require("react/jsx-runtime");
 var defaultTableFilterTranslation = {
   en: {
@@ -8573,16 +11331,16 @@ var TableFilterButton = ({
 }) => {
   const translation = useTranslation([formTranslation, defaultTableFilterTranslation]);
   const columnFilterValue = column.getFilterValue();
-  const [filterValue, setFilterValue] = (0, import_react33.useState)(columnFilterValue);
+  const [filterValue, setFilterValue] = (0, import_react34.useState)(columnFilterValue);
   const hasFilter = !!filterValue;
-  (0, import_react33.useEffect)(() => {
+  (0, import_react34.useEffect)(() => {
     setFilterValue(columnFilterValue);
   }, [columnFilterValue]);
   return /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(
     Menu,
     {
       trigger: ({ toggleOpen }, ref) => /* @__PURE__ */ (0, import_jsx_runtime58.jsxs)("div", { ref, className: "relative", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(IconButton, { color: "neutral", size: "tiny", onClick: toggleOpen, children: /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(import_lucide_react20.FilterIcon, {}) }),
+        /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(IconButton, { color: "neutral", size: "tiny", onClick: toggleOpen, children: /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(import_lucide_react21.FilterIcon, {}) }),
         hasFilter && /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(
           "div",
           {
@@ -8676,7 +11434,7 @@ var TableFilterButton = ({
 };
 
 // src/components/table/TableSortButton.tsx
-var import_lucide_react21 = require("lucide-react");
+var import_lucide_react22 = require("lucide-react");
 var import_clsx46 = __toESM(require("clsx"));
 var import_jsx_runtime59 = require("react/jsx-runtime");
 var TableSortButton = ({
@@ -8686,13 +11444,13 @@ var TableSortButton = ({
   className,
   ...buttonProps
 }) => {
-  let icon = /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_lucide_react21.ChevronsUpDown, { className: "w-full h-full" });
+  let icon = /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_lucide_react22.ChevronsUpDown, { className: "w-full h-full" });
   if (sortDirection) {
     let usedSortDirection = sortDirection;
     if (invert) {
       usedSortDirection = usedSortDirection === "desc" ? "asc" : "desc";
     }
-    icon = usedSortDirection === "asc" ? /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_lucide_react21.ChevronUp, { className: "w-full h-full" }) : /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_lucide_react21.ChevronDown, { className: "w-full h-full" });
+    icon = usedSortDirection === "asc" ? /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_lucide_react22.ChevronUp, { className: "w-full h-full" }) : /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_lucide_react22.ChevronDown, { className: "w-full h-full" });
   }
   return /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(
     IconButton,
@@ -8707,9 +11465,9 @@ var TableSortButton = ({
 };
 
 // src/hooks/useResizeCallbackWrapper.ts
-var import_react34 = require("react");
+var import_react35 = require("react");
 var useResizeCallbackWrapper = (callback) => {
-  (0, import_react34.useEffect)(() => {
+  (0, import_react35.useEffect)(() => {
     window.addEventListener("resize", callback);
     return () => {
       window.removeEventListener("resize", callback);
@@ -8741,22 +11499,22 @@ var Table = ({
   columns,
   ...tableOptions
 }) => {
-  const ref = (0, import_react35.useRef)(null);
-  const tableRef = (0, import_react35.useRef)(null);
-  const [columnSizing, setColumnSizing] = (0, import_react35.useState)(columns.reduce((previousValue, currentValue) => {
+  const ref = (0, import_react36.useRef)(null);
+  const tableRef = (0, import_react36.useRef)(null);
+  const [columnSizing, setColumnSizing] = (0, import_react36.useState)(columns.reduce((previousValue, currentValue) => {
     return {
       ...previousValue,
       [currentValue.id]: currentValue.minSize ?? defaultColumn.minSize
     };
   }, {}));
-  const [columnSizingInfo, setColumnSizingInfo] = (0, import_react35.useState)();
-  const [pagination, setPagination] = (0, import_react35.useState)({
+  const [columnSizingInfo, setColumnSizingInfo] = (0, import_react36.useState)();
+  const [pagination, setPagination] = (0, import_react36.useState)({
     pageSize: 10,
     pageIndex: 0,
     ...initialState?.pagination
   });
-  const [columnFilters, setColumnFilters] = (0, import_react35.useState)(initialState?.columnFilters);
-  const computedColumnMinWidths = (0, import_react35.useMemo)(() => {
+  const [columnFilters, setColumnFilters] = (0, import_react36.useState)(initialState?.columnFilters);
+  const computedColumnMinWidths = (0, import_react36.useMemo)(() => {
     return columns.reduce((previousValue, column) => {
       return {
         ...previousValue,
@@ -8765,7 +11523,7 @@ var Table = ({
       };
     }, {});
   }, [columns, defaultColumn]);
-  const computedColumnMaxWidths = (0, import_react35.useMemo)(() => {
+  const computedColumnMaxWidths = (0, import_react36.useMemo)(() => {
     return columns.reduce((previousValue, column) => {
       return {
         ...previousValue,
@@ -8773,12 +11531,12 @@ var Table = ({
       };
     }, {});
   }, [columns, defaultColumn]);
-  const tableMinWidth = (0, import_react35.useMemo)(() => {
+  const tableMinWidth = (0, import_react36.useMemo)(() => {
     return columns.reduce((sum, column) => {
       return sum + computedColumnMinWidths[column.id];
     }, 0);
   }, [columns, computedColumnMinWidths]);
-  const updateColumnSizes = (0, import_react35.useMemo)(() => {
+  const updateColumnSizes = (0, import_react36.useMemo)(() => {
     return (previous) => {
       const updateSizing = {
         ...columnSizing,
@@ -8895,18 +11653,18 @@ var Table = ({
     columnResizeMode: "onChange",
     ...tableOptions
   });
-  const [hasInitializedSizing, setHasInitializedSizing] = (0, import_react35.useState)(false);
-  (0, import_react35.useEffect)(() => {
+  const [hasInitializedSizing, setHasInitializedSizing] = (0, import_react36.useState)(false);
+  (0, import_react36.useEffect)(() => {
     if (!hasInitializedSizing && ref.current) {
       setHasInitializedSizing(true);
       table.setColumnSizing(updateColumnSizes(columnSizing));
     }
   }, [columnSizing, hasInitializedSizing]);
-  useResizeCallbackWrapper((0, import_react35.useCallback)(() => {
+  useResizeCallbackWrapper((0, import_react36.useCallback)(() => {
     table.setColumnSizing(updateColumnSizes);
   }, [updateColumnSizes]));
   const pageCount = table.getPageCount();
-  (0, import_react35.useEffect)(() => {
+  (0, import_react36.useEffect)(() => {
     const totalPages = pageCount;
     if (totalPages === 0) {
       if (pagination.pageIndex !== 0) {
@@ -8922,7 +11680,7 @@ var Table = ({
       }));
     }
   }, [data, pageCount, pagination.pageSize, pagination.pageIndex]);
-  const columnSizeVars = (0, import_react35.useMemo)(() => {
+  const columnSizeVars = (0, import_react36.useMemo)(() => {
     const headers = table.getFlatHeaders();
     const colSizes = {};
     for (let i = 0; i < headers.length; i++) {
@@ -9037,8 +11795,8 @@ var Table = ({
   ] });
 };
 var TableUncontrolled = ({ data, ...props }) => {
-  const [usedDate, setUsedData] = (0, import_react35.useState)(data);
-  (0, import_react35.useEffect)(() => {
+  const [usedDate, setUsedData] = (0, import_react36.useState)(data);
+  (0, import_react36.useEffect)(() => {
     setUsedData(data);
   }, [data]);
   return /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
@@ -9060,7 +11818,7 @@ var TableWithSelection = ({
   meta,
   ...props
 }) => {
-  const columnsWithSelection = (0, import_react35.useMemo)(() => {
+  const columnsWithSelection = (0, import_react36.useMemo)(() => {
     return [
       {
         id: selectionRowId,
@@ -9130,7 +11888,7 @@ var TableWithSelection = ({
 };
 
 // src/components/user-action/CopyToClipboardWrapper.tsx
-var import_react36 = require("react");
+var import_react37 = require("react");
 var import_clsx49 = require("clsx");
 
 // src/util/writeToClipboard.ts
@@ -9139,7 +11897,7 @@ var writeToClipboard = (text) => {
 };
 
 // src/components/user-action/CopyToClipboardWrapper.tsx
-var import_lucide_react22 = require("lucide-react");
+var import_lucide_react23 = require("lucide-react");
 var import_jsx_runtime62 = require("react/jsx-runtime");
 var CopyToClipboardWrapper = ({
   children,
@@ -9150,8 +11908,8 @@ var CopyToClipboardWrapper = ({
   zIndex = 10
 }) => {
   const translation = useTranslation([formTranslation]);
-  const [isShowingIndication, setIsShowingIndication] = (0, import_react36.useState)(false);
-  const [isShowingConfirmation, setIsShowingConfirmation] = (0, import_react36.useState)(false);
+  const [isShowingIndication, setIsShowingIndication] = (0, import_react37.useState)(false);
+  const [isShowingConfirmation, setIsShowingConfirmation] = (0, import_react37.useState)(false);
   const positionClasses = {
     top: `bottom-full left-1/2 -translate-x-1/2 mb-[6px]`,
     bottom: `top-full left-1/2 -translate-x-1/2 mt-[6px]`,
@@ -9205,11 +11963,11 @@ var CopyToClipboardWrapper = ({
             },
             children: [
               isShowingConfirmation && /* @__PURE__ */ (0, import_jsx_runtime62.jsxs)("div", { className: "flex-row-1", children: [
-                /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(import_lucide_react22.CheckIcon, { size: 16, className: "text-positive" }),
+                /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(import_lucide_react23.CheckIcon, { size: 16, className: "text-positive" }),
                 translation("copied")
               ] }),
               isShowingIndication && /* @__PURE__ */ (0, import_jsx_runtime62.jsxs)("div", { className: "flex-row-1 text-description", children: [
-                /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(import_lucide_react22.Copy, { size: 16 }),
+                /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(import_lucide_react23.Copy, { size: 16 }),
                 translation("clickToCopy")
               ] }),
               /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(
@@ -9293,7 +12051,7 @@ var DateTimePicker = ({
 };
 
 // src/components/user-action/ScrollPicker.tsx
-var import_react37 = require("react");
+var import_react38 = require("react");
 var import_clsx51 = __toESM(require("clsx"));
 var import_jsx_runtime64 = require("react/jsx-runtime");
 var up = 1;
@@ -9314,7 +12072,7 @@ var ScrollPicker = ({
     transition,
     items,
     lastTimeStamp
-  }, setAnimation] = (0, import_react37.useState)({
+  }, setAnimation] = (0, import_react38.useState)({
     targetIndex: selectedIndex,
     currentIndex: disabled ? selectedIndex : 0,
     velocity: 0,
@@ -9330,7 +12088,7 @@ var ScrollPicker = ({
   const itemHeight = 40;
   const distance = 8;
   const containerHeight = itemHeight * (itemsShownCount - 2) + distance * (itemsShownCount - 2 + 1);
-  const getDirection = (0, import_react37.useCallback)((targetIndex, currentIndex2, transition2, length) => {
+  const getDirection = (0, import_react38.useCallback)((targetIndex, currentIndex2, transition2, length) => {
     if (targetIndex === currentIndex2) {
       return transition2 > 0 ? up : down;
     }
@@ -9340,7 +12098,7 @@ var ScrollPicker = ({
     }
     return distanceForward >= length / 2 ? down : up;
   }, []);
-  const animate = (0, import_react37.useCallback)((timestamp, startTime) => {
+  const animate = (0, import_react38.useCallback)((timestamp, startTime) => {
     setAnimation((prevState) => {
       const {
         targetIndex,
@@ -9413,7 +12171,7 @@ var ScrollPicker = ({
       };
     });
   }, [disabled, getDirection, onChange]);
-  (0, import_react37.useEffect)(() => {
+  (0, import_react38.useEffect)(() => {
     requestAnimationFrame((timestamp) => animate(timestamp, lastTimeStamp));
   });
   const opacity = (transition2, index, itemsCount) => {
@@ -9448,7 +12206,7 @@ var ScrollPicker = ({
         /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(
           "div",
           {
-            className: "absolute z-[1] top-1/2 -translate-y-1/2 -translate-x-1/2 left-1/2 w-full min-w-[40px] border border-divider/30 border-y-2 border-x-0 ",
+            className: "absolute z-[1] top-1/2 -translate-y-1/2 -translate-x-1/2 left-1/2 w-full min-w-[40px] border border-divider/50 border-y-2 border-x-0 ",
             style: { height: `${itemHeight}px` }
           }
         ),
@@ -9490,8 +12248,8 @@ var ScrollPicker = ({
 };
 
 // src/components/user-action/ToggleableInput.tsx
-var import_react38 = require("react");
-var import_lucide_react23 = require("lucide-react");
+var import_react39 = require("react");
+var import_lucide_react24 = require("lucide-react");
 var import_clsx52 = __toESM(require("clsx"));
 var import_jsx_runtime65 = require("react/jsx-runtime");
 var ToggleableInput = ({
@@ -9508,14 +12266,14 @@ var ToggleableInput = ({
   saveDelayOptions,
   ...restProps
 }) => {
-  const [isEditing, setIsEditing] = (0, import_react38.useState)(initialState !== "display");
+  const [isEditing, setIsEditing] = (0, import_react39.useState)(initialState !== "display");
   const { restartTimer, clearTimer } = useDelay(saveDelayOptions);
-  const ref = (0, import_react38.useRef)(null);
+  const ref = (0, import_react39.useRef)(null);
   const onEditCompletedWrapper = (text) => {
     onEditCompleted(text);
     clearTimer();
   };
-  (0, import_react38.useEffect)(() => {
+  (0, import_react39.useEffect)(() => {
     if (isEditing) {
       ref.current?.focus();
     }
@@ -9562,7 +12320,7 @@ var ToggleableInput = ({
             }
           ) : /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("span", { className: (0, import_clsx52.default)("max-w-xs break-words overflow-hidden", labelClassName), children: value }) }),
           /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-            import_lucide_react23.Pencil,
+            import_lucide_react24.Pencil,
             {
               className: (0, import_clsx52.default)(`cursor-pointer`, { "text-transparent": isEditing }),
               size,
@@ -9580,8 +12338,8 @@ var ToggleableInputUncontrolled = ({
   onChangeText = noop,
   ...restProps
 }) => {
-  const [value, setValue] = (0, import_react38.useState)(initialValue);
-  (0, import_react38.useEffect)(() => {
+  const [value, setValue] = (0, import_react39.useState)(initialValue);
+  (0, import_react39.useEffect)(() => {
     setValue(initialValue);
   }, [initialValue]);
   return /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
@@ -9597,10 +12355,36 @@ var ToggleableInputUncontrolled = ({
   );
 };
 
+// src/hooks/useLogOnce.ts
+var import_react40 = require("react");
+var useLogOnce = ({
+  message,
+  condition,
+  type = "warning"
+}) => {
+  const [hasLogged, setHasLogged] = (0, import_react40.useState)(false);
+  (0, import_react40.useEffect)(() => {
+    if (!hasLogged && condition) {
+      switch (type) {
+        case "info":
+          console.info(message);
+          break;
+        case "error":
+          console.error(message);
+          break;
+        case "warning":
+          console.warn(message);
+          break;
+      }
+      setHasLogged(true);
+    }
+  }, [condition]);
+};
+
 // src/hooks/useRerender.ts
-var import_react39 = require("react");
+var import_react41 = require("react");
 var useRerender = () => {
-  return (0, import_react39.useReducer)(() => ({}), {})[1];
+  return (0, import_react41.useReducer)(() => ({}), {})[1];
 };
 
 // src/util/builder.ts
@@ -9693,6 +12477,7 @@ var filterNews = (localizedNews, requiredKeys) => {
   LanguageModal,
   LanguageProvider,
   LanguageUtil,
+  ListTile,
   LoadingAndErrorComponent,
   LoadingAnimation,
   LoadingButton,
@@ -9722,7 +12507,6 @@ var filterNews = (localizedNews, requiredKeys) => {
   SearchBar,
   SearchableList,
   Select,
-  SelectTile,
   SelectUncontrolled,
   SessionStorageService,
   SimpleSearch,