@servicetitan/anvil2 1.44.2 → 1.45.1

package/dist/ProgressBar-BRvB-bD4-DppwBrFg.js

@@ -1,2616 +0,0 @@
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { useState, useRef, useEffect, forwardRef, useId, createContext, useContext, useCallback, useMemo, cloneElement, isValidElement, Fragment as Fragment$1, useLayoutEffect } from 'react';
-import { c as cx } from './index-tZvMCc77.js';
-import { I as Icon } from './Icon-B6HmlQiR-BxQkO3X5.js';
-import { a as SvgCheckCircle, S as SvgError, b as SvgInfo } from './check_circle-BGfigqq-.js';
-import { B as tabbable, C as useDelayGroup, F as FloatingPortal, b as FloatingArrow, p as computePosition, n as autoUpdate, o as offset, f as flip, d as shift, e as arrow$1, l as limitShift, D as useDelayGroupContext, c as useFloating, h as useHover, i as safePolygon, E as useFocus, j as useDismiss, k as useRole, m as useInteractions } from './floating-ui.react-BFNinq1w.js';
-import { a as PortalProviderContext } from './PortalProvider-9lXkQ0xY-BKoGegS1.js';
-import { S as SvgClose } from './close-DZj38AEh.js';
-import { T as Text } from './Text-CED_yrId-DsRYZw2-.js';
-import { B as Button } from './Button-BaHFf1AT-BQy-PFB5.js';
-import { A as Alert } from './Alert-C3WoRkeN-D_6Yf63F.js';
-import { F as Flex } from './Flex-CiK7uNUu-BfxHG4L0.js';
-import { u as useLayoutPropsUtil } from './useLayoutPropsUtil-DWACCL8v-CZNrcQT-.js';
-import { H as Helper } from './Helper-h7k80qls-DHPFHTvI.js';
-import { u as useSwipe } from './useSwipe-CULmVQEk-CULmVQEk.js';
-import { S as SrOnly } from './SrOnly-BsKDHetF-B93X65F1.js';
-import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
-import { T as ThemeProvider, a as ThemeProviderContext } from './ThemeProvider-Q3ji6Rpx-DBXlAuQ8.js';
-import { g as getKeyboardFocusableElements } from './getKeyboardFocusableElements-QqcABz0D.js';
-import { u as useTooltipLegacyGroup } from './HammerProvider-vt3DkcCZ-06BeBrPu.js';
-
-import './ProgressBar-BRvB-bD4.css';/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-var byteToHex = [];
-for (var i = 0; i < 256; ++i) {
-  byteToHex.push((i + 0x100).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  // Note: Be careful editing this code!  It's been tuned for performance
-  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-  //
-  // Note to future-self: No, you can't remove the `toLowerCase()` call.
-  // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// Unique ID creation requires a high quality random # generator. In the browser we therefore
-// require the crypto API and do not support built-in fallback to lower quality random number
-// generators (like Math.random()).
-
-var getRandomValues;
-var rnds8 = new Uint8Array(16);
-function rng() {
-  // lazy load so that environments that need to polyfill have a chance to do so
-  if (!getRandomValues) {
-    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
-    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
-    if (!getRandomValues) {
-      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-    }
-  }
-  return getRandomValues(rnds8);
-}
-
-var randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const native = {
-  randomUUID
-};
-
-function v4(options, buf, offset) {
-  if (native.randomUUID && true && !options) {
-    return native.randomUUID();
-  }
-  options = options || {};
-  var rnds = options.random || (options.rng || rng)();
-
-  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-  rnds[6] = rnds[6] & 0x0f | 0x40;
-  rnds[8] = rnds[8] & 0x3f | 0x80;
-  return unsafeStringify(rnds);
-}
-
-const useKeyboardFocusables = (element, options = {
-  observeChange: true,
-  attributes: true,
-  characterData: true,
-  childList: true,
-  subtree: true
-}) => {
-  const [focusables, setFocusables] = useState(null);
-  const observerRef = useRef();
-  useEffect(() => {
-    const target = element instanceof HTMLElement ? element : element?.current;
-    if (!target) return;
-    if (observerRef.current) return;
-    if (!options.observeChange && !focusables) {
-      setFocusables(tabbable(target));
-      return;
-    }
-    let timeoutId = null;
-    const debounceDelay = 100;
-    const mutationCallback = () => {
-      const targetArr = tabbable(target);
-      if (targetArr.length === 0) return;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      timeoutId = setTimeout(() => {
-        setFocusables(targetArr);
-      }, debounceDelay);
-    };
-    const observer = new MutationObserver(mutationCallback);
-    observerRef.current = observer;
-    observer.observe(target, {
-      childList: true,
-      // Observe changes to child elements
-      subtree: true,
-      // Observe changes to descendants of the target
-      attributes: true,
-      // Observe changes to attributes
-      characterData: true
-      // Observe changes to text content
-    });
-  }, [element, options]);
-  useEffect(() => {
-    return () => {
-      if (!observerRef.current) return;
-      observerRef.current.disconnect();
-    };
-  }, []);
-  const updateFocusables = () => {
-    const target = element instanceof HTMLElement ? element : element?.current;
-    if (!target) return;
-    setFocusables(tabbable(target));
-  };
-  return { focusables, updateFocusables };
-};
-
-const useOnClickOutside = ({
-  onOutsidePress,
-  targets,
-  onClose
-}) => {
-  useEffect(() => {
-    if (typeof document === "undefined") return;
-    let isClosable = false;
-    const onMouseDownHandler = (e) => {
-      let isTarget = false;
-      const path = e.composedPath();
-      for (const el of targets) {
-        if (el && path.includes(el)) {
-          isTarget = true;
-          break;
-        }
-      }
-      if (!isTarget) {
-        onOutsidePress?.(e);
-        isClosable = true;
-      }
-    };
-    const onMouseUpHandler = (e) => {
-      if (!isClosable) return;
-      let isTarget = false;
-      const path = e.composedPath();
-      for (const el of targets) {
-        if (el && path.includes(el)) {
-          isTarget = true;
-          break;
-        }
-      }
-      if (!isTarget) {
-        onClose?.();
-      }
-    };
-    document.addEventListener("mousedown", onMouseDownHandler);
-    document.addEventListener("mouseup", onMouseUpHandler);
-    return () => {
-      document.removeEventListener("mousedown", onMouseDownHandler);
-      document.removeEventListener("mouseup", onMouseUpHandler);
-    };
-  }, [onClose, onOutsidePress, targets]);
-};
-
-const getActiveElement = (activeDocument) => {
-  const activeElement = activeDocument.activeElement;
-  if (!activeElement) {
-    return activeElement;
-  }
-  if (activeElement.tagName === "IFRAME") {
-    const iframes = Array.from(document.getElementsByTagName("iframe"));
-    if (iframes.includes(activeElement)) {
-      const iframeActiveElement = activeElement;
-      const iframeActiveDocument = iframeActiveElement.contentDocument || iframeActiveElement.contentWindow?.document;
-      if (!iframeActiveDocument) return activeElement;
-      return getActiveElement(iframeActiveDocument);
-    }
-  }
-  if (!activeElement.shadowRoot) {
-    return activeElement;
-  }
-  if (activeElement.shadowRoot) {
-    return getActiveElement(activeElement.shadowRoot);
-  }
-  return activeElement;
-};
-
-const label = "_label_jfzvd_2";
-const required = "_required_jfzvd_46";
-const styles$5 = {
-	label: label,
-	"top-container": "_top-container_jfzvd_37",
-	"label-text": "_label-text_jfzvd_42",
-	required: required,
-	"info-trigger": "_info-trigger_jfzvd_51",
-	"info-content": "_info-content_jfzvd_56"
-};
-
-const content$1 = "_content_1tuax_2";
-const scroller = "_scroller_1tuax_29";
-const arrow = "_arrow_1tuax_32";
-const trigger = "_trigger_1tuax_39";
-const styles$4 = {
-	content: content$1,
-	scroller: scroller,
-	arrow: arrow,
-	trigger: trigger
-};
-
-const TooltipContext = createContext(null);
-
-function useTooltipContext() {
-  const context = useContext(TooltipContext);
-  const invokerRef = useRef(null);
-  const popoverRef = useRef(null);
-  const arrowRef = useRef(null);
-  useLayoutEffect(() => {
-    if (!invokerRef.current) return;
-    context?.setInvoker?.(invokerRef.current);
-    if (!context?.openState) return;
-    context.openTooltip();
-  }, [context, invokerRef]);
-  useLayoutEffect(() => {
-    if (!popoverRef.current) return;
-    context?.setTooltip?.(popoverRef.current);
-    context?.setRootNode?.(popoverRef.current.getRootNode());
-    if (!arrowRef.current) return;
-    context?.setArrowElement?.(arrowRef.current);
-  }, [context, popoverRef]);
-  const onMouseEnterHandler = () => {
-    if (context?.controlled) return;
-    context?.openTooltip();
-  };
-  const onMouseLeaveHandler = () => {
-    if (context?.controlled) return;
-    context?.closeTooltip();
-  };
-  const onFocusHandler = () => {
-    if (context?.controlled) return;
-    context?.openTooltip();
-  };
-  const onBlurHandler = () => {
-    if (context?.controlled) return;
-    context?.closeTooltip();
-  };
-  const onKeyDownHandler = (e) => {
-    if (!context?.openState) return;
-    if (e.code === "Escape" && !context.controlled) {
-      context?.closeTooltip();
-      return;
-    }
-  };
-  if (!context || !invokerRef || !popoverRef) return;
-  return {
-    invoker: {
-      ref: invokerRef,
-      element: context.invoker,
-      onMouseEnter: onMouseEnterHandler,
-      onMouseLeave: onMouseLeaveHandler,
-      onKeyDown: onKeyDownHandler,
-      onFocus: onFocusHandler,
-      onBlur: onBlurHandler,
-      "aria-haspopup": true,
-      "aria-details": context.tooltipId,
-      "data-state": context.openState ? "open" : "closed",
-      "aria-describedby": context.tooltipId
-    },
-    tooltip: {
-      ref: popoverRef,
-      element: context.popover,
-      id: context.tooltipId,
-      setId: context.setTooltipId,
-      show: context.openTooltip,
-      close: context.closeTooltip,
-      style: context.tooltipStyle,
-      arrowRef,
-      key: context.resetKey
-    },
-    setOpen: context.setOpenState,
-    open: context.openState,
-    controlled: context.controlled,
-    placement: context.placement,
-    disableFlipFallback: context.disableFlipFallback
-  };
-}
-
-function supportsPopover() {
-  return Object.prototype.hasOwnProperty.call(HTMLElement.prototype, "popover");
-}
-
-const TooltipLegacyContext = createContext(null);
-const useTooltipLegacyContext = () => {
-  const context = useContext(TooltipLegacyContext);
-  if (context == null) {
-    throw new Error(
-      "TooltipLegacy components must be wrapped in <TooltipLegacy />"
-    );
-  }
-  return context;
-};
-
-const styles$3 = {
-	"content-legacy": "_content-legacy_3w3om_3",
-	"arrow-legacy": "_arrow-legacy_3w3om_29",
-	"trigger-legacy": "_trigger-legacy_3w3om_32"
-};
-
-const ATTRIBUTE_NAME_LIST = "data-anv-dialogs";
-const ATTRIBUTE_NAME_BOOL = "data-anv-dialogs-open";
-const useDialogScrollLock = ({
-  open,
-  id,
-  enableScrollChaining,
-  elementRef
-}) => {
-  useEffect(() => {
-    if (enableScrollChaining) return () => {
-    };
-    const root = elementRef.current?.getRootNode();
-    if (!(root instanceof ShadowRoot)) return () => {
-    };
-    const updateDialogAttributes = (shouldAdd) => {
-      const currentDialogs = root.host.getAttribute(ATTRIBUTE_NAME_LIST)?.split(" ").filter(Boolean) ?? [];
-      const newDialogs = new Set(currentDialogs);
-      if (shouldAdd) {
-        newDialogs.add(id);
-      } else {
-        newDialogs.delete(id);
-      }
-      const dialogList = Array.from(newDialogs);
-      root.host.setAttribute(ATTRIBUTE_NAME_LIST, dialogList.join(" "));
-      if (dialogList.length > 0) {
-        root.host.setAttribute(ATTRIBUTE_NAME_BOOL, "true");
-      } else {
-        root.host.removeAttribute(ATTRIBUTE_NAME_BOOL);
-      }
-    };
-    updateDialogAttributes(open);
-    return () => {
-      updateDialogAttributes(false);
-    };
-  }, [open, id, enableScrollChaining, elementRef]);
-};
-
-const DialogContext = createContext(null);
-
-const ToastProviderContext = createContext({
-  toasts: [],
-  setToasts: () => [],
-  toastHeights: [],
-  setToastHeights: () => [],
-  getToastStackHeight: () => 0,
-  toastsBeforeStack: 3,
-  setToastsBeforeStack: () => [],
-  extraToastsVisible: false,
-  setExtraToastsVisible: () => [],
-  isDialogToaster: false
-});
-const ToastProvider = ({
-  children,
-  isDialogToaster: isDialogToasterProp = false
-}) => {
-  const [toasts, setToasts] = useState([]);
-  const [toastHeights, setToastHeights] = useState([]);
-  const [toastsBeforeStack, setToastsBeforeStack] = useState(3);
-  const [extraToastsVisible, setExtraToastsVisible] = useState(false);
-  const [isDialogToaster, setIsDialogToaster] = useState(isDialogToasterProp);
-  const removeDuplicateToasts = (toasts2) => {
-    const toastIds = /* @__PURE__ */ new Set();
-    const uniqueToasts = toasts2.filter((toast) => {
-      if (toastIds.has(toast.id)) {
-        console.error(
-          `Encountered toast with duplicate id ${toast.id}. Each toast id needs to be unique.`
-        );
-        return false;
-      } else {
-        toastIds.add(toast.id);
-        return true;
-      }
-    });
-    return uniqueToasts;
-  };
-  useEffect(() => {
-    const uniqueToasts = removeDuplicateToasts(toasts);
-    if (toasts.length !== uniqueToasts.length) {
-      setToasts(uniqueToasts);
-    }
-  }, [toasts]);
-  useEffect(() => {
-    setIsDialogToaster(isDialogToasterProp);
-  }, [isDialogToasterProp]);
-  const getToastStackHeight = useCallback(
-    (index) => {
-      const toastHeightsOnly = toastHeights.filter((_t, i) => {
-        return index !== void 0 ? i > index : true;
-      }).map((t) => t.height);
-      if (toastHeightsOnly.length > 0) {
-        if (extraToastsVisible) {
-          return toastHeightsOnly.reduce((totalHeight, currentHeight) => {
-            return totalHeight + currentHeight;
-          });
-        }
-        return toastHeightsOnly.filter((_t, i) => i >= toastHeightsOnly.length - toastsBeforeStack).reduce((totalHeight, currentHeight) => {
-          return totalHeight + currentHeight;
-        });
-      }
-      return 0;
-    },
-    [toastHeights, extraToastsVisible, toastsBeforeStack]
-  );
-  const value = useMemo(
-    () => ({
-      toasts,
-      setToasts,
-      toastHeights,
-      setToastHeights,
-      getToastStackHeight,
-      toastsBeforeStack,
-      setToastsBeforeStack,
-      extraToastsVisible,
-      setExtraToastsVisible,
-      isDialogToaster
-    }),
-    [
-      extraToastsVisible,
-      getToastStackHeight,
-      toastHeights,
-      toasts,
-      toastsBeforeStack,
-      isDialogToaster
-    ]
-  );
-  return /* @__PURE__ */ jsx(ToastProviderContext.Provider, { value, children });
-};
-const useToasts = () => {
-  const context = useContext(ToastProviderContext);
-  if (context == null) {
-    throw new Error("useToasts must be wrapped in <ToastProvider />");
-  }
-  return context;
-};
-
-const popover = "_popover_x2c3m_2";
-const toaster = "_toaster_x2c3m_9";
-const hidden = "_hidden_x2c3m_24";
-const stacked = "_stacked_x2c3m_89";
-const open = "_open_x2c3m_184";
-const close = "_close_x2c3m_185";
-const styles$2 = {
-	popover: popover,
-	toaster: toaster,
-	hidden: hidden,
-	"toast-stack": "_toast-stack_x2c3m_27",
-	"toast-wrapper": "_toast-wrapper_x2c3m_40",
-	"toast-alert": "_toast-alert_x2c3m_54",
-	"alert-action": "_alert-action_x2c3m_60",
-	"message-container": "_message-container_x2c3m_66",
-	"show-extra-toast": "_show-extra-toast_x2c3m_75",
-	stacked: stacked,
-	"stack-one": "_stack-one_x2c3m_92",
-	"stack-two": "_stack-two_x2c3m_92",
-	"stacked-show-extra": "_stacked-show-extra_x2c3m_108",
-	"stacked-extra": "_stacked-extra_x2c3m_122",
-	"show-more-button-container": "_show-more-button-container_x2c3m_135",
-	"show-collapse-button-container": "_show-collapse-button-container_x2c3m_136",
-	"show-collapse-button": "_show-collapse-button_x2c3m_136",
-	"disable-animations": "_disable-animations_x2c3m_160",
-	open: open,
-	close: close};
-
-const ANIMATION_DURATION = 300;
-const useShowMoreButtonPositionStyles = () => {
-  const { toastHeights, toastsBeforeStack } = useToasts();
-  const totalToasts = toastHeights.length;
-  const extraSpace = totalToasts > toastsBeforeStack + 1 ? "2rem" : "1rem";
-  const top = useMemo(() => {
-    if (totalToasts > toastsBeforeStack) {
-      return toastHeights.filter((_t, i) => i >= totalToasts - toastsBeforeStack).map((t) => t.height).reduce((t, c) => t + c);
-    }
-    return "unset";
-  }, [toastHeights, toastsBeforeStack]);
-  return {
-    // -0.75px fixes hover issue when 1rem != 16px due to pixel rounding
-    top: `calc(${top}px + ${extraSpace} - 0.75px)`,
-    position: "absolute",
-    display: totalToasts > toastsBeforeStack ? void 0 : "none"
-  };
-};
-const STACKED_TOAST_HEIGHT = "5.3125rem";
-const STACKED_TOAST_PEEK_HEIGHT = "1rem";
-const TOAST_GAP = `${24 / 16}rem`;
-const useToastPositionStyles = (index) => {
-  const {
-    toasts,
-    toastHeights,
-    getToastStackHeight,
-    toastsBeforeStack,
-    extraToastsVisible
-  } = useToasts();
-  const toastCount = toasts.length;
-  const toasterHeight = getToastStackHeight(index);
-  return useMemo(() => {
-    if (index === toastCount - 1) {
-      return {
-        top: TOAST_GAP,
-        zIndex: 3
-      };
-    } else if (
-      // all toasts when show more is clicked
-      extraToastsVisible || // or visible toasts when stacked
-      !extraToastsVisible && (toastCount <= toastsBeforeStack || toastCount > toastsBeforeStack && index >= toastCount - toastsBeforeStack)
-    ) {
-      return {
-        top: `calc(${toasterHeight}px + ${TOAST_GAP})`
-      };
-    } else {
-      if (toastCount > toastsBeforeStack) {
-        if (index === toastCount - toastsBeforeStack - 1) {
-          return {
-            top: `calc(${toasterHeight || 0}px - ${STACKED_TOAST_HEIGHT} +
-              ${STACKED_TOAST_PEEK_HEIGHT})`,
-            zIndex: 1
-          };
-        } else if (index <= toastCount - toastsBeforeStack - 2) {
-          return {
-            top: `calc(${toasterHeight || 0}px -
-              ${STACKED_TOAST_HEIGHT} 
-             + ${STACKED_TOAST_PEEK_HEIGHT} * 2)`,
-            zIndex: 0
-          };
-        }
-      }
-    }
-    return void 0;
-  }, [toastHeights]);
-};
-const addOrUpdateToastHeight = (toastId, toastHeight, setToastHeights) => {
-  setToastHeights((prev) => {
-    if (prev.find((t) => t.id === toastId)) {
-      return prev.map((t) => {
-        if (t.id === toastId) {
-          return { ...t, height: toastHeight };
-        }
-        return t;
-      });
-    }
-    return [
-      ...prev,
-      {
-        id: toastId,
-        height: toastHeight
-      }
-    ];
-  });
-};
-const setToastsAfterClose = (setToasts, setToastHeights, id) => {
-  setToasts((prev) => id ? prev.filter((t) => t.id !== id) : []);
-  setToastHeights((prev) => id ? prev.filter((t) => t.id !== id) : []);
-};
-const closeToast = (setToasts, setToastHeights, closingToastClassName, id) => {
-  const prefersReducedMotion = globalThis.matchMedia(
-    `(prefers-reduced-motion: reduce)`
-  ).matches;
-  if (prefersReducedMotion) {
-    setToastsAfterClose(setToasts, setToastHeights, id);
-  } else {
-    setToasts(
-      (prev) => prev.map((t) => {
-        if (!id || t.id === id) {
-          return {
-            ...t,
-            toastClassName: closingToastClassName
-          };
-        }
-        return t;
-      })
-    );
-    setTimeout(() => {
-      setToastsAfterClose(setToasts, setToastHeights, id);
-    }, ANIMATION_DURATION - 10);
-  }
-};
-const useCloseToast = (closingToastClassName) => {
-  const { setToasts, setToastHeights } = useToasts();
-  return (id) => {
-    closeToast(setToasts, setToastHeights, closingToastClassName, id);
-  };
-};
-
-const toast = () => {
-  const toastMethods = [
-    "info",
-    "success",
-    "warning",
-    "danger",
-    "promise",
-    "update",
-    "dismiss"
-  ];
-  console.error(
-    "Please use one of the following toast methods:\n",
-    ...toastMethods.map((m) => `	toast.${m}()
-`)
-  );
-};
-const TOAST_EVENT_NAME = "hammer-toast";
-const TOAST_TYPES = ["info", "success", "warning", "danger"];
-const methods = {};
-TOAST_TYPES.forEach((type) => {
-  methods[type] = (props) => {
-    const uniqueId = v4();
-    const ToastAddEvent = new CustomEvent(TOAST_EVENT_NAME, {
-      composed: true,
-      detail: {
-        id: uniqueId,
-        eventType: "add",
-        status: type,
-        createdAt: Date.now(),
-        ...props
-      }
-    });
-    dispatchEvent(ToastAddEvent);
-    return uniqueId;
-  };
-});
-const update = (id, props) => {
-  const ToastEvent = new CustomEvent(
-    TOAST_EVENT_NAME,
-    {
-      composed: true,
-      detail: {
-        eventType: "update",
-        id,
-        ...props
-      }
-    }
-  );
-  dispatchEvent(ToastEvent);
-};
-const dismiss = (id) => {
-  const ToastEvent = new CustomEvent(
-    TOAST_EVENT_NAME,
-    {
-      composed: true,
-      detail: {
-        eventType: "dismiss",
-        id
-      }
-    }
-  );
-  dispatchEvent(ToastEvent);
-};
-const promise = async (promise2, toastConfig) => {
-  const { onClose, ...loadingToastConfig } = toastConfig.loading;
-  let closedWhileLoading = false;
-  const onCloseWhileLoading = (e) => {
-    toastConfig.loading.onClose?.(e);
-    closedWhileLoading = true;
-  };
-  const id = toast.info({
-    ...loadingToastConfig,
-    onClose: onCloseWhileLoading,
-    duration: false
-  });
-  await Promise.resolve(promise2).then((res) => {
-    if (closedWhileLoading) {
-      toast.success({
-        ...toastConfig.success(res)
-      });
-    } else {
-      toast.update(id, {
-        ...toastConfig.success(res),
-        status: "success"
-      });
-    }
-  }).catch((err) => {
-    if (closedWhileLoading) {
-      toast.danger({
-        ...toastConfig.error(err)
-      });
-    } else {
-      toast.update(id, {
-        ...toastConfig.error(err),
-        status: "danger"
-      });
-    }
-  });
-  return id;
-};
-toast.info = methods.info;
-toast.success = methods.success;
-toast.warning = methods.warning;
-toast.danger = methods.danger;
-toast.update = update;
-toast.dismiss = dismiss;
-toast.promise = promise;
-
-const Toast = forwardRef(
-  ({
-    actions,
-    containerClassName,
-    createdAt,
-    duration: durationProp,
-    index = 0,
-    isBelowStackIndex,
-    isStacked,
-    message,
-    onClose,
-    onDismiss,
-    pausedStatus,
-    progress,
-    toastClassName,
-    ...alertProps
-  }, ref) => {
-    const { setToastHeights, extraToastsVisible, isDialogToaster } = useToasts();
-    const closeToast = useCloseToast(styles$2.close);
-    const toastPositionStyles = useToastPositionStyles(index);
-    const toastWrapperRef = useRef(null);
-    const timerRef = useRef();
-    const pausedAtRef = useRef(0);
-    const createdAtRef = useRef(createdAt ?? 0);
-    const hasBeenStackedRef = useRef(false);
-    const [transitionClass, setTransitionClass] = useState(
-      styles$2.hidden
-    );
-    const [toastOpened, setToastOpened] = useState(false);
-    const duration = actions ? false : durationProp;
-    const alertClasses = cx(
-      styles$2["toast-alert"],
-      toastClassName,
-      transitionClass
-    );
-    useEffect(() => {
-      if (!toastOpened) {
-        setTransitionClass(styles$2.open);
-        setTimeout(() => {
-          setTransitionClass(void 0);
-        }, ANIMATION_DURATION);
-        setToastOpened(true);
-      }
-      return () => {
-        onDismiss?.();
-      };
-    }, []);
-    useEffect(() => {
-      if (toastWrapperRef.current && toastOpened && !isStacked) {
-        if (isBelowStackIndex && extraToastsVisible || isDialogToaster) {
-          const delay = isDialogToaster ? 0 : ANIMATION_DURATION;
-          setTimeout(() => {
-            const height = toastWrapperRef.current?.clientHeight;
-            addOrUpdateToastHeight(alertProps.id, height ?? 0, setToastHeights);
-          }, delay);
-        } else {
-          const height = toastWrapperRef.current.clientHeight;
-          addOrUpdateToastHeight(alertProps.id, height, setToastHeights);
-        }
-      }
-    }, [
-      toastOpened,
-      isStacked,
-      extraToastsVisible,
-      isDialogToaster,
-      // toast updates
-      actions,
-      message,
-      alertProps.title
-    ]);
-    useEffect(() => {
-      if (duration && !isStacked) {
-        if (!pausedStatus) {
-          timerRef.current = setTimeout(
-            () => closeToast(alertProps.id),
-            duration
-          );
-          return () => clearTimeout(timerRef.current);
-        } else if (typeof pausedStatus === "number") {
-          clearTimeout(timerRef.current);
-          pausedAtRef.current = pausedStatus;
-        } else if (pausedStatus === "resumed") {
-          const remainingDuration = (
-            // rendering new toast after initial hover
-            pausedAtRef.current === 0 ? duration : (
-              // resume timer after valid hover
-              duration + (createdAtRef.current || 0) - pausedAtRef.current
-            )
-          );
-          timerRef.current = setTimeout(() => {
-            closeToast(alertProps.id);
-            pausedAtRef.current = 0;
-          }, remainingDuration);
-          return () => clearTimeout(timerRef.current);
-        }
-      }
-    }, [createdAtRef.current, duration, pausedStatus]);
-    useEffect(() => {
-      if (duration) {
-        if (isStacked) {
-          clearTimeout(timerRef.current);
-          hasBeenStackedRef.current = true;
-        } else if (!isStacked && hasBeenStackedRef.current && !(typeof pausedStatus === "number")) {
-          createdAtRef.current = Date.now();
-          timerRef.current = setTimeout(() => {
-            closeToast(alertProps.id);
-            hasBeenStackedRef.current = false;
-          }, duration);
-          return () => clearTimeout(timerRef.current);
-        }
-      }
-    }, [isStacked, duration]);
-    const onSwipe = (dir) => {
-      if (dir === "right") {
-        toast.dismiss(alertProps.id);
-        return;
-      }
-    };
-    const { direction, ...touchProps } = useSwipe(onSwipe);
-    const alertCloseProps = isStacked && !extraToastsVisible ? {} : {
-      onClose
-    };
-    const hasMessage = message && message !== "";
-    const hasProgress = progress != null;
-    return /* @__PURE__ */ jsx(
-      "div",
-      {
-        "data-anv": "toast",
-        className: containerClassName,
-        style: toastPositionStyles ?? { top: "1.5rem" },
-        ref: toastWrapperRef,
-        onAnimationStart: () => setToastOpened(true),
-        role: isStacked ? "presentation" : void 0,
-        ...touchProps,
-        children: /* @__PURE__ */ jsx(
-          Alert,
-          {
-            className: alertClasses,
-            ...alertProps,
-            ...alertCloseProps,
-            ref,
-            tabIndex: isStacked && !extraToastsVisible ? -1 : 0,
-            children: hasMessage || hasProgress || actions ? /* @__PURE__ */ jsxs(Fragment, { children: [
-              hasMessage ? /* @__PURE__ */ jsx(
-                "div",
-                {
-                  className: styles$2["message-container"],
-                  id: `toast-message-${alertProps.id}`,
-                  children: message
-                }
-              ) : null,
-              hasProgress ? /* @__PURE__ */ jsx(Fragment, { children: progress === "indeterminate" ? /* @__PURE__ */ jsx(
-                ProgressBar,
-                {
-                  "aria-labelledby": `toast-message-${alertProps.id}`,
-                  indeterminate: true
-                }
-              ) : /* @__PURE__ */ jsx(
-                ProgressBar,
-                {
-                  "aria-labelledby": `toast-message-${alertProps.id}`,
-                  value: progress
-                }
-              ) }) : null,
-              actions ? /* @__PURE__ */ jsxs("div", { className: styles$2["alert-action"], children: [
-                /* @__PURE__ */ jsx(
-                  Button,
-                  {
-                    appearance: actions.primary.appearance,
-                    onClick: actions.primary.onClick,
-                    size: "small",
-                    children: actions.primary.label
-                  }
-                ),
-                actions.secondary && /* @__PURE__ */ jsx(
-                  Button,
-                  {
-                    appearance: actions.secondary.appearance,
-                    onClick: actions.secondary.onClick,
-                    size: "small",
-                    children: actions.secondary.label
-                  }
-                )
-              ] }) : null
-            ] }) : null
-          }
-        )
-      }
-    );
-  }
-);
-Toast.displayName = "Toast";
-
-function useHotkeyFocus({
-  disabled,
-  hotkey,
-  onHotkeyIn,
-  onHotkeyOut,
-  refToFocus,
-  rootRef
-}) {
-  const [shouldEscapeRefocus, setShouldEscapeRefocus] = useState(false);
-  const previousFocusElement = useRef(null);
-  useEffect(() => {
-    if (disabled || typeof document === "undefined") return;
-    const rootElement = rootRef.current;
-    const blurHandler = (e) => {
-      if (e.relatedTarget && rootElement.contains(e.relatedTarget)) {
-        return;
-      }
-      setShouldEscapeRefocus(false);
-    };
-    const keyDownHandler = async (e) => {
-      const activeElement = getActiveElement(document);
-      if (activeElement?.tagName.toLowerCase() !== "input" && activeElement?.tagName.toLowerCase() !== "textarea" && activeElement?.tagName.toLowerCase() !== "pre" && e.key === hotkey) {
-        e.preventDefault();
-        previousFocusElement.current = activeElement;
-        await onHotkeyIn?.();
-        if (refToFocus.current) {
-          refToFocus.current.focus();
-          setShouldEscapeRefocus(true);
-          if (refToFocus.current.scrollTo) {
-            refToFocus.current.scrollTo();
-          }
-        }
-      } else if (e.code === "Escape" && shouldEscapeRefocus) {
-        onHotkeyOut?.();
-        if (previousFocusElement.current && previousFocusElement.current.tagName.toLowerCase() !== "body") {
-          previousFocusElement.current.focus();
-        } else {
-          activeElement.blur();
-        }
-      }
-    };
-    document.addEventListener("keydown", keyDownHandler);
-    rootElement.addEventListener("focusout", blurHandler);
-    return () => {
-      document.removeEventListener("keydown", keyDownHandler);
-      rootElement.removeEventListener("focusout", blurHandler);
-    };
-  }, [
-    hotkey,
-    disabled,
-    rootRef,
-    shouldEscapeRefocus,
-    onHotkeyIn,
-    refToFocus,
-    onHotkeyOut
-  ]);
-  return { returnFocusRef: previousFocusElement };
-}
-
-const ToastStack = forwardRef(
-  ({
-    className,
-    duration = false,
-    focusKey = "t",
-    toasts,
-    toastsBeforeStack = 3,
-    ...props
-  }, ref) => {
-    const toastStackRef = useRef(null);
-    const firstToastRef = useRef(null);
-    const mergedToastStackRef = useMergeRefs([toastStackRef, ref]);
-    const {
-      setToastsBeforeStack,
-      extraToastsVisible,
-      setExtraToastsVisible,
-      getToastStackHeight,
-      isDialogToaster
-    } = useToasts();
-    const toastCount = toasts.length;
-    const isToastStackEmpty = toastCount === 0;
-    const lastToastCount = useRef(0);
-    const [toastStackHeight, setToastStackHeight] = useState(0);
-    const [disableAnimations, setDisableAnimations] = useState(false);
-    const [toastPausedStatus, setToastPausedStatus] = useState(void 0);
-    useEffect(() => {
-      if (toastCount === 0) {
-        setToastPausedStatus(void 0);
-      }
-    }, [toastCount]);
-    useEffect(() => {
-      const scrollListener = (e) => {
-        e.preventDefault();
-        e.stopPropagation();
-        toastStackRef.current?.scrollTo({
-          top: toastStackRef.current.scrollTop + e.deltaY
-        });
-      };
-      if (isDialogToaster) {
-        setDisableAnimations(isDialogToaster);
-        setTimeout(() => {
-          setDisableAnimations(false);
-        }, 500);
-        const toastStackRefCurrent = toastStackRef.current;
-        toastStackRefCurrent?.addEventListener("wheel", scrollListener, {
-          passive: false
-        });
-        return () => {
-          toastStackRefCurrent?.removeEventListener("wheel", scrollListener);
-        };
-      }
-    }, [isDialogToaster]);
-    useEffect(() => {
-      let timer;
-      if (toastCount > lastToastCount.current || isDialogToaster) {
-        setToastStackHeight(getToastStackHeight());
-      } else {
-        timer = setTimeout(
-          () => setToastStackHeight(getToastStackHeight()),
-          ANIMATION_DURATION - 10
-        );
-      }
-      lastToastCount.current = toastCount;
-      return () => {
-        clearTimeout(timer);
-      };
-    }, [getToastStackHeight, isDialogToaster]);
-    useEffect(() => {
-      setToastsBeforeStack(toastsBeforeStack);
-    }, [setToastsBeforeStack, toastsBeforeStack]);
-    const handleToastStackBlur = useCallback(() => {
-      setExtraToastsVisible(false);
-      setToastPausedStatus("resumed");
-      if (toastStackRef.current?.scrollTo) {
-        toastStackRef.current?.scrollTo(0, 0);
-      }
-    }, [setExtraToastsVisible]);
-    const { returnFocusRef } = useHotkeyFocus({
-      disabled: isToastStackEmpty,
-      hotkey: focusKey,
-      onHotkeyIn: async () => {
-        setExtraToastsVisible(true);
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve();
-          }, 100);
-        });
-      },
-      onHotkeyOut: () => {
-        setExtraToastsVisible(false);
-        handleToastStackBlur();
-      },
-      refToFocus: firstToastRef,
-      rootRef: toastStackRef
-    });
-    const showMoreButtonPositionStyles = useShowMoreButtonPositionStyles();
-    const showMoreButton = !extraToastsVisible && toastCount > toastsBeforeStack;
-    const extraToastsLength = toastCount - toastsBeforeStack;
-    const showMoreButtonText = `${extraToastsLength} more message${extraToastsLength > 1 ? "s" : ""}`;
-    const toastStackClasses = cx(styles$2["toast-stack"], className, {
-      [styles$2["show-more-button"]]: showMoreButton,
-      [styles$2["show-extra-toast"]]: extraToastsVisible,
-      [styles$2["disable-animations"]]: disableAnimations
-    });
-    const handleToastStackFocusHover = () => {
-      if (toastPausedStatus === "resumed" || toastPausedStatus === void 0) {
-        setToastPausedStatus(Date.now());
-      }
-    };
-    const handleToastStackOnBlur = () => {
-      if (!toastStackRef.current?.matches(":focus-within")) {
-        handleToastStackBlur();
-      }
-    };
-    const handleShowMoreButtonClick = () => {
-      setExtraToastsVisible(true);
-    };
-    let toastStackHeightStyle = 0;
-    if (extraToastsVisible) {
-      toastStackHeightStyle = "calc(100vh - var(--toast-stack-padding) * 2)";
-    } else if (toastCount > toastsBeforeStack) {
-      toastStackHeightStyle = `calc(${toastStackHeight}px + 3rem + var(--toast-stack-padding))`;
-    } else {
-      toastStackHeightStyle = toastStackHeight;
-    }
-    return /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsxs(
-        "div",
-        {
-          "data-anv": "ToastStack",
-          className: toastStackClasses,
-          ref: mergedToastStackRef,
-          onMouseOver: handleToastStackFocusHover,
-          onMouseLeave: handleToastStackBlur,
-          onFocus: handleToastStackFocusHover,
-          onBlur: handleToastStackOnBlur,
-          style: {
-            height: toastStackHeightStyle
-          },
-          ...props,
-          children: [
-            toasts.map(({ toastClassName, onClose, ...toastProps }, index) => {
-              const isStacked = !extraToastsVisible && index < toastCount - toastsBeforeStack;
-              const isLastToastDisplayed = index === toastCount - toastsBeforeStack;
-              const isHidden = index < toastCount - toastsBeforeStack - 2;
-              const toastClasses = cx(styles$2.toast, toastClassName);
-              const toastContainerClasses = cx(styles$2["toast-wrapper"], {
-                [styles$2.stacked]: isStacked || isLastToastDisplayed,
-                [styles$2["stack-one"]]: isStacked && index === toastCount - toastsBeforeStack - 1,
-                [styles$2["stack-two"]]: isStacked && index === toastCount - toastsBeforeStack - 2,
-                [styles$2["stacked-extra"]]: isHidden,
-                [styles$2["stacked-show-extra"]]: extraToastsVisible
-              });
-              const handleOnClose = (e) => {
-                onClose?.(e);
-                returnFocusRef.current?.focus();
-                toast.dismiss(toastProps.id);
-              };
-              return /* @__PURE__ */ jsx(
-                Toast,
-                {
-                  containerClassName: toastContainerClasses,
-                  duration,
-                  index,
-                  isStacked,
-                  isBelowStackIndex: index < toastCount - toastsBeforeStack,
-                  onClose: handleOnClose,
-                  pausedStatus: toastPausedStatus,
-                  toastClassName: toastClasses,
-                  ref: index === 0 ? firstToastRef : void 0,
-                  ...toastProps
-                },
-                toastProps.id
-              );
-            }),
-            showMoreButton && /* @__PURE__ */ jsx(
-              "div",
-              {
-                className: styles$2["show-more-button-container"],
-                style: showMoreButtonPositionStyles,
-                children: /* @__PURE__ */ jsx(
-                  Button,
-                  {
-                    className: styles$2["show-collapse-button"],
-                    onClick: handleShowMoreButtonClick,
-                    appearance: "secondary",
-                    tabIndex: 0,
-                    children: showMoreButtonText
-                  }
-                )
-              }
-            ),
-            /* @__PURE__ */ jsxs(SrOnly, { "aria-live": "polite", children: [
-              "New toast message appeared. Press the ",
-              focusKey,
-              " key to focus on the toast messages. Press escape to return focus to previous position."
-            ] })
-          ]
-        }
-      ),
-      extraToastsVisible && /* @__PURE__ */ jsx("div", { className: styles$2["show-collapse-button-container"], children: /* @__PURE__ */ jsx(
-        Button,
-        {
-          className: styles$2["show-collapse-button"],
-          onClick: handleToastStackBlur,
-          appearance: "secondary",
-          children: "Collapse Messages"
-        }
-      ) })
-    ] });
-  }
-);
-ToastStack.displayName = "ToastStack";
-
-const safeShowPopover = (element) => {
-  try {
-    element?.showPopover();
-  } catch (e) {
-    console.warn(e);
-  }
-};
-const safeHidePopover = (element) => {
-  try {
-    element?.hidePopover();
-  } catch (e) {
-    console.warn(e);
-  }
-};
-
-const ToasterPopover = forwardRef(
-  (props, ref) => {
-    const { isDialogToaster } = useToasts();
-    const popoverRef = useRef(null);
-    const combinedRef = useMergeRefs([popoverRef, ref]);
-    const { toasts } = useToasts();
-    const toastCount = useMemo(() => toasts.length, [toasts]);
-    useEffect(() => {
-      if (!popoverRef.current) return;
-      if (!supportsPopover()) {
-        console.error("Popover is not supported in this browser");
-        return;
-      }
-      const currentPopover = popoverRef.current;
-      let timeout;
-      if (toastCount > 0) {
-        if (isDialogToaster) {
-          timeout = setTimeout(() => {
-            safeHidePopover(currentPopover);
-            safeShowPopover(currentPopover);
-          });
-        } else {
-          safeShowPopover(currentPopover);
-        }
-      } else {
-        safeHidePopover(currentPopover);
-      }
-      return () => {
-        if (timeout) clearTimeout(timeout);
-        if (toastCount === 0) {
-          safeHidePopover(currentPopover);
-        }
-      };
-    }, [toastCount, isDialogToaster]);
-    return /* @__PURE__ */ jsx("div", { ref: combinedRef, className: styles$2.popover, popover: "manual", children: props.children });
-  }
-);
-ToasterPopover.displayName = "ToasterPopover";
-
-const ToasterContent = forwardRef(
-  ({
-    className,
-    disableEvents = false,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- pulling out of props
-    forceRender = false,
-    id,
-    onToastEvent,
-    // ToastStackProps
-    duration,
-    focusKey,
-    toastsBeforeStack,
-    ...props
-  }, ref) => {
-    const toasterRef = useRef(null);
-    const mergedToasterRef = useMergeRefs([toasterRef, ref]);
-    const { toasts, setToasts, isDialogToaster } = useToasts();
-    const disableEventsRef = useRef(disableEvents);
-    const toastCountRef = useRef(0);
-    const isDialogToasterRef = useRef(isDialogToaster);
-    const [shouldHideToaster, setShouldHideToaster] = useState(false);
-    const updateDialogToasterStorage = useCallback(
-      (isDialogToaster2) => {
-        const dialogToasters = JSON.parse(
-          window.sessionStorage.getItem("dialog-toasters") ?? "[]"
-        );
-        if (isDialogToaster2) {
-          if (!dialogToasters.includes(id)) {
-            window.sessionStorage.setItem(
-              "dialog-toasters",
-              JSON.stringify([...dialogToasters, id])
-            );
-          }
-        } else if (dialogToasters.includes(id)) {
-          window.sessionStorage.setItem(
-            "dialog-toasters",
-            JSON.stringify(
-              dialogToasters.filter(
-                (dialogToaster) => dialogToaster !== id
-              )
-            )
-          );
-        }
-      },
-      [id]
-    );
-    useEffect(() => {
-      disableEventsRef.current = disableEvents;
-    }, [disableEvents]);
-    useEffect(() => {
-      toastCountRef.current = toasts.length;
-    }, [toasts.length]);
-    useEffect(() => {
-      updateDialogToasterStorage(isDialogToaster);
-      isDialogToasterRef.current = isDialogToaster;
-      const DialogToasterEvent = new CustomEvent("dialog-toaster", {
-        composed: true,
-        detail: {
-          eventType: "dialog-toaster"
-        }
-      });
-      dispatchEvent(DialogToasterEvent);
-    }, [isDialogToaster]);
-    const closeToast = useCloseToast(styles$2.close);
-    useEffect(() => {
-      let timeout;
-      updateDialogToasterStorage(isDialogToaster);
-      const toastEventListener = (e) => {
-        if (disableEventsRef.current) {
-          return;
-        }
-        const { eventType, ...toastProps } = e.detail;
-        if (eventType === "add") {
-          const toastAddProps = toastProps;
-          if (!toastAddProps.toasterId || toastAddProps.toasterId === id) {
-            setToasts((prev) => [...prev, toastProps]);
-          }
-          timeout = setTimeout(() => {
-            onToastEvent?.({
-              eventType: "add",
-              toastCount: toastCountRef.current,
-              id: toastAddProps.id,
-              toasterId: id,
-              toastProps: toastAddProps
-            });
-          });
-        } else if (eventType === "update") {
-          const toastUpdateProps = toastProps;
-          setToasts((prev) => {
-            return prev.map((t) => {
-              if (t.id === toastUpdateProps.id) {
-                return {
-                  ...t,
-                  ...toastUpdateProps
-                };
-              } else {
-                return t;
-              }
-            });
-          });
-          onToastEvent?.({
-            eventType: "update",
-            toastCount: toastCountRef.current,
-            id: toastUpdateProps.id,
-            toasterId: id,
-            toastProps: toastUpdateProps
-          });
-        } else if (eventType === "dismiss") {
-          if (toastProps.id) {
-            closeToast(toastProps.id);
-            timeout = setTimeout(() => {
-              onToastEvent?.({
-                eventType: "dismiss",
-                toastCount: toastCountRef.current,
-                id: toastProps.id,
-                toasterId: id
-              });
-            }, ANIMATION_DURATION);
-          } else {
-            closeToast();
-            onToastEvent?.({
-              eventType: "dismiss-all",
-              toastCount: 0,
-              toasterId: id
-            });
-          }
-        }
-      };
-      const dialogToasterEventListener = (e) => {
-        const { eventType } = e.detail;
-        if (eventType === "dialog-toaster") {
-          const dialogToasters = JSON.parse(
-            window.sessionStorage.getItem("dialog-toasters") ?? "[]"
-          );
-          if (dialogToasters.length > 0) {
-            if (isDialogToasterRef.current && dialogToasters[dialogToasters.length - 1] === id) {
-              setShouldHideToaster(false);
-            } else {
-              setShouldHideToaster(true);
-            }
-          } else {
-            setShouldHideToaster(false);
-          }
-        }
-      };
-      const onPageRefreshListener = () => {
-        window.sessionStorage.removeItem("dialog-toasters");
-      };
-      window.addEventListener("hammer-toast", toastEventListener);
-      window.addEventListener("dialog-toaster", dialogToasterEventListener);
-      window.addEventListener("beforeunload", onPageRefreshListener);
-      return () => {
-        window.removeEventListener("hammer-toast", toastEventListener);
-        window.removeEventListener(
-          "dialog-toaster",
-          dialogToasterEventListener
-        );
-        window.removeEventListener("beforeunload", onPageRefreshListener);
-        clearTimeout(timeout);
-        updateDialogToasterStorage(false);
-      };
-    }, []);
-    const toasterClasses = cx(styles$2.toaster, {
-      [styles$2["hidden"]]: shouldHideToaster,
-      [`${className}`]: className != null
-    });
-    return /* @__PURE__ */ jsx(
-      "div",
-      {
-        "data-anv": "toaster",
-        "data-toaster-id": id,
-        "aria-hidden": shouldHideToaster,
-        className: toasterClasses,
-        ref: mergedToasterRef,
-        ...props,
-        children: /* @__PURE__ */ jsx(
-          ToastStack,
-          {
-            toasts,
-            duration,
-            focusKey,
-            toastsBeforeStack
-          }
-        )
-      }
-    );
-  }
-);
-const Toaster = forwardRef(
-  (props, ref) => {
-    return /* @__PURE__ */ jsx(ToastProvider, { children: /* @__PURE__ */ jsx(ToasterPopover, { children: /* @__PURE__ */ jsx(ToasterContent, { ...props, ref }) }) });
-  }
-);
-Toaster.displayName = "Toaster";
-ToasterContent.displayName = "ToasterContent";
-
-const useOpenCloseTransitionStates = (openProp, options = {
-  durationMs: 0
-}) => {
-  const {
-    onOpenAnimationStart,
-    onCloseAnimationStart,
-    onOpenAnimationComplete,
-    onCloseAnimationComplete,
-    durationMs
-  } = options;
-  const prevOpenProp = useRef(openProp);
-  const [state, setState] = useState(
-    openProp ? "open" : "closed"
-  );
-  useEffect(() => {
-    if (prevOpenProp.current && !openProp) {
-      setState("closing");
-    } else if (!prevOpenProp.current && openProp) {
-      setState("opening");
-    } else {
-      setState(openProp ? "opening" : "closed");
-    }
-    prevOpenProp.current = openProp;
-  }, [openProp]);
-  useEffect(() => {
-    if (!durationMs) return;
-    if (state === "open" || state === "closed") return;
-    if (state === "opening") {
-      onOpenAnimationStart?.();
-    } else if (state === "closing") {
-      onCloseAnimationStart?.();
-    }
-    const d = typeof durationMs === "function" ? durationMs() : durationMs;
-    const timeout = setTimeout(() => {
-      if (state === "opening") {
-        setState("open");
-        onOpenAnimationComplete?.();
-      } else if (state === "closing") {
-        setState("closed");
-        onCloseAnimationComplete?.();
-      }
-    }, d);
-    return () => {
-      clearTimeout(timeout);
-    };
-  }, [
-    state,
-    onOpenAnimationComplete,
-    onCloseAnimationComplete,
-    onOpenAnimationStart,
-    onCloseAnimationStart,
-    durationMs
-  ]);
-  const beginClosing = useCallback(() => {
-    setState("closing");
-  }, []);
-  return {
-    state,
-    beginClosing,
-    isOpenOrOpening: state === "open" || state === "opening",
-    isClosedOrClosing: state === "closed" || state === "closing"
-  };
-};
-
-const useDialogTransitionStates = (ref, openProp, options = {}) => {
-  const { onOpenAnimationStart, onCloseAnimationComplete } = options;
-  return useOpenCloseTransitionStates(openProp, {
-    ...options,
-    onOpenAnimationStart: () => {
-      if (!ref.current) return;
-      ref.current.showModal();
-      onOpenAnimationStart?.();
-    },
-    onCloseAnimationComplete: () => {
-      if (!ref.current) return;
-      ref.current.close();
-      onCloseAnimationComplete?.();
-    },
-    durationMs: () => {
-      if (!ref.current) return 0;
-      const duration = window.getComputedStyle(ref.current).animationDuration;
-      return parseFloat(duration) * 1e3;
-    }
-  });
-};
-
-const drawer = "_drawer_1jl82_2";
-const container = "_container_1jl82_28";
-const content = "_content_1jl82_41";
-const header = "_header_1jl82_48";
-const footer = "_footer_1jl82_72";
-const remove = "_remove_1jl82_90";
-const large = "_large_1jl82_99";
-const sticky = "_sticky_1jl82_102";
-const styles$1 = {
-	drawer: drawer,
-	container: container,
-	content: content,
-	header: header,
-	"close-container": "_close-container_1jl82_65",
-	footer: footer,
-	remove: remove,
-	large: large,
-	sticky: sticky,
-	"close-button": "_close-button_1jl82_108"
-};
-
-const DrawerCancelButton = forwardRef((props, ref) => {
-  const { onClick, ...rest } = props;
-  const { close } = useDrawerContext();
-  const onClickHandler = (e) => {
-    onClick?.(e);
-    close();
-  };
-  return /* @__PURE__ */ jsx(
-    Button,
-    {
-      "aria-label": "Close drawer",
-      "data-anv": "drawer-cancel-button",
-      onClick: onClickHandler,
-      ref,
-      ...rest
-    }
-  );
-});
-DrawerCancelButton.displayName = "DrawerCancelButton";
-
-const DrawerHeader = forwardRef(
-  (props, ref) => {
-    const { className, children } = props;
-    const drawerHeaderClasses = cx(styles$1.header, className);
-    return /* @__PURE__ */ jsxs(
-      "header",
-      {
-        className: drawerHeaderClasses,
-        "data-anv": "drawer-header",
-        ref,
-        children: [
-          /* @__PURE__ */ jsx(Text, { variant: "headline", el: "h1", children }),
-          /* @__PURE__ */ jsx("span", { className: styles$1["close-container"], children: /* @__PURE__ */ jsx(
-            DrawerCancelButton,
-            {
-              className: styles$1["close-button"],
-              size: "small",
-              appearance: "ghost",
-              "aria-label": "Close drawer",
-              "data-anv": "drawer-header-close-button",
-              icon: SvgClose
-            }
-          ) })
-        ]
-      }
-    );
-  }
-);
-DrawerHeader.displayName = "DrawerHeader";
-
-const DrawerFooter = forwardRef(
-  (props, ref) => {
-    const { className, children, sticky = false, ...rest } = props;
-    const drawerFooterClasses = cx(styles$1.footer, className, {
-      [styles$1["sticky"]]: sticky
-    });
-    return /* @__PURE__ */ jsx(
-      "footer",
-      {
-        className: drawerFooterClasses,
-        "data-anv": "drawer-footer",
-        ref,
-        ...rest,
-        children
-      }
-    );
-  }
-);
-DrawerFooter.displayName = "DrawerFooter";
-
-const DrawerContent = forwardRef(
-  (props, ref) => {
-    const { className, children, ...rest } = props;
-    const drawerContentClasses = cx(styles$1.content, className);
-    return /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: drawerContentClasses,
-        "data-anv": "drawer-content",
-        ref,
-        ...rest,
-        children
-      }
-    );
-  }
-);
-DrawerContent.displayName = "DrawerContent";
-
-const DrawerContext = createContext(null);
-const DrawerElement = forwardRef(
-  (props, ref) => {
-    const {
-      className,
-      open = false,
-      children,
-      onOpen,
-      onClose,
-      /* eslint-disable-next-line @typescript-eslint/no-unused-vars --
-        onCancel is destructured so that it is not passed to the dialog in ...rest
-      */
-      onCancel,
-      onKeyDown,
-      disableCloseOnEscape = false,
-      onClickOutside,
-      disableCloseOnClickOutside = false,
-      size = "medium",
-      enableScrollChaining,
-      onOpenAnimationStart,
-      onOpenAnimationComplete,
-      onCloseAnimationStart,
-      onCloseAnimationComplete,
-      ...rest
-    } = props;
-    const elRef = useRef(null);
-    const contentRef = useRef(null);
-    const toasterRef = useRef(null);
-    const combinedRef = useMergeRefs([elRef, ref]);
-    const id = useId();
-    const { state, isOpenOrOpening } = useDialogTransitionStates(elRef, open, {
-      onOpenAnimationStart: useCallback(() => {
-        onOpenAnimationStart?.();
-      }, [onOpenAnimationStart]),
-      onOpenAnimationComplete: useCallback(() => {
-        onOpenAnimationComplete?.();
-        onOpen?.();
-      }, [onOpen, onOpenAnimationComplete]),
-      onCloseAnimationStart: useCallback(() => {
-        onCloseAnimationStart?.();
-      }, [onCloseAnimationStart]),
-      onCloseAnimationComplete: useCallback(() => {
-        onCloseAnimationComplete?.();
-      }, [onCloseAnimationComplete])
-    });
-    const classNames = cx([styles$1.drawer], className, {
-      [styles$1.remove]: state === "closing",
-      [styles$1.large]: size === "large"
-    });
-    const { focusables } = useKeyboardFocusables(contentRef, {
-      observeChange: false
-    });
-    const firstFocusable = focusables?.[0];
-    const lastFocusable = focusables?.[focusables.length - 1];
-    useDialogScrollLock({
-      open: isOpenOrOpening,
-      id,
-      enableScrollChaining,
-      elementRef: elRef
-    });
-    useEffect(() => {
-      if (!isOpenOrOpening) return;
-      if (!focusables) return;
-      const activeElement = getActiveElement(document);
-      if (!activeElement) return;
-      if (activeElement.dataset.anv !== "drawer-header-close-button" && (focusables.includes(activeElement) || activeElement.tagName === "DIALOG")) {
-        return;
-      }
-      if (focusables[0]?.dataset.anv === "drawer-header-close-button" && focusables[1]) {
-        focusables[1].focus();
-      } else {
-        focusables[0]?.focus();
-      }
-    }, [isOpenOrOpening, focusables]);
-    const onCancelHandler = (e) => {
-      e.preventDefault();
-      if (disableCloseOnEscape) return;
-      onClose?.();
-    };
-    useOnClickOutside({
-      onOutsidePress: (e) => {
-        if (!open) return;
-        onClickOutside?.(e);
-      },
-      targets: [
-        contentRef.current,
-        toasterRef.current
-      ],
-      onClose: () => {
-        if (disableCloseOnClickOutside || !open) return;
-        onClose?.();
-      }
-    });
-    const onKeyDownHandler = (e) => {
-      onKeyDown?.(e);
-      if (e.code === "Tab") {
-        if (e.shiftKey && e.target === firstFocusable) {
-          e.preventDefault();
-          lastFocusable?.focus();
-          return;
-        }
-        if (e.target === lastFocusable && !e.shiftKey) {
-          e.preventDefault();
-          firstFocusable?.focus();
-          return;
-        }
-      }
-    };
-    const contextValue = useMemo(() => {
-      return { close: () => onClose?.() };
-    }, [onClose]);
-    return (
-      // dialog element does seem to be interactive on MDN guideline
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions
-      /* @__PURE__ */ jsxs(
-        "dialog",
-        {
-          className: classNames,
-          "data-anv": "drawer",
-          "data-anv-scroll-chaining": enableScrollChaining,
-          "data-anv-transition-state": state,
-          ref: combinedRef,
-          onCancel: onCancelHandler,
-          onKeyDown: onKeyDownHandler,
-          ...rest,
-          children: [
-            /* @__PURE__ */ jsx(ToastProvider, { isDialogToaster: isOpenOrOpening, children: /* @__PURE__ */ jsx(ToasterPopover, { children: /* @__PURE__ */ jsx(ToasterContent, { id: "drawer-toaster", ref: toasterRef }) }) }),
-            /* @__PURE__ */ jsx(DrawerContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
-              "section",
-              {
-                ref: contentRef,
-                className: styles$1.container,
-                "data-open": isOpenOrOpening,
-                children
-              }
-            ) })
-          ]
-        }
-      )
-    );
-  }
-);
-function useDrawerContext() {
-  const context = useContext(DrawerContext);
-  if (!context) {
-    throw new Error(
-      "useDrawerContext must be used within a DrawerContextProvider"
-    );
-  }
-  return context;
-}
-DrawerElement.displayName = "Drawer";
-const Drawer = Object.assign(DrawerElement, {
-  /**
-   * Header component for the drawer that displays a title and close button.
-   *
-   * Features:
-   * - Displays the drawer title as a headline
-   * - Includes an accessible close button
-   * - Sticky positioning at the top of the drawer
-   * - Proper semantic HTML structure
-   * - Accessible with proper ARIA attributes
-   * - Consistent styling with the design system
-   * - Automatic close functionality
-   *
-   * @example
-   * <Drawer.Header>Settings</Drawer.Header>
-   */
-  Header: DrawerHeader,
-  /**
-   * Footer component for the drawer that displays action buttons and controls.
-   *
-   * Features:
-   * - Flexible layout for action buttons and controls
-   * - Optional sticky positioning at the bottom
-   * - Proper semantic HTML structure
-   * - Accessible with proper ARIA attributes
-   * - Consistent styling with the design system
-   * - Supports all standard footer element props
-   * - Responsive design that adapts to content
-   *
-   * @example
-   * <Drawer.Footer sticky>
-   *   <Button onClick={handleSave}>Save</Button>
-   *   <Drawer.CancelButton>Cancel</Drawer.CancelButton>
-   * </Drawer.Footer>
-   */
-  Footer: DrawerFooter,
-  /**
-   * Content container for the drawer that holds the main content area.
-   *
-   * Features:
-   * - Flexible content area with proper spacing
-   * - Scrollable content when needed
-   * - Proper semantic HTML structure
-   * - Accessible with proper ARIA attributes
-   * - Consistent styling with the design system
-   * - Supports all standard div element props
-   * - Responsive design that adapts to content
-   * - Proper focus management
-   *
-   * @example
-   * <Drawer.Content>
-   *   <p>This is the main content of the drawer.</p>
-   *   <p>It can contain any type of content.</p>
-   * </Drawer.Content>
-   */
-  Content: DrawerContent,
-  /**
-   * A button component that automatically closes the drawer when clicked.
-   *
-   * Features:
-   * - Automatically closes the drawer when clicked
-   * - Extends Button component functionality
-   * - Accessible with proper ARIA attributes
-   * - Consistent styling with the design system
-   * - Supports all standard button props
-   * - Proper focus management
-   * - Can be used anywhere within the drawer context
-   *
-   * @example
-   * <Drawer.CancelButton appearance="ghost" size="small">
-   *   Cancel
-   * </Drawer.CancelButton>
-   */
-  CancelButton: DrawerCancelButton
-});
-
-const TooltipLegacyContent = forwardRef(function TooltipLegacyContent2({ style, className, ...props }, propRef) {
-  const {
-    context: floatingContext,
-    theme,
-    mode,
-    root,
-    ...context
-  } = useTooltipLegacyContext();
-  const { root: portalRoot } = useContext(PortalProviderContext);
-  const dialogContext = useContext(DialogContext);
-  const drawerContext = useContext(DrawerContext);
-  const id = useId();
-  useDelayGroup(floatingContext, { id });
-  const ref = useMergeRefs([context.refs.setFloating, propRef]);
-  if (!floatingContext.open) return null;
-  const contentCx = cx(styles$3["content-legacy"], className);
-  return /* @__PURE__ */ jsx(
-    FloatingPortal,
-    {
-      root: root ?? dialogContext?.ref?.current ?? drawerContext?.ref?.current ?? portalRoot ?? context.refs.reference,
-      children: /* @__PURE__ */ jsx(ThemeProvider, { theme, mode, children: /* @__PURE__ */ jsxs(
-        "div",
-        {
-          ref,
-          className: contentCx,
-          "data-anv": "tooltip-content",
-          style: {
-            ...context.floatingStyles,
-            ...style
-          },
-          onBlur: () => context.setOpen(false),
-          ...context.getFloatingProps(props),
-          children: [
-            /* @__PURE__ */ jsx(
-              FloatingArrow,
-              {
-                ref: context.arrowRef,
-                context: floatingContext,
-                className: styles$3["arrow-legacy"]
-              }
-            ),
-            props.children
-          ]
-        }
-      ) })
-    }
-  );
-});
-
-const TooltipContentElement = forwardRef(
-  function TooltipContent2(props, ref) {
-    const {
-      children,
-      className,
-      style,
-      onMouseEnter,
-      onMouseLeave,
-      onKeyDown,
-      onFocus,
-      onBlur,
-      id,
-      ...rest
-    } = props;
-    const context = useTooltipContext();
-    const { mode: currentMode } = useContext(ThemeProviderContext);
-    const tooltipClassNames = cx(className, styles$4["content"]);
-    const childrenRef = useRef(null);
-    const focusItems = useRef();
-    const combinedStyles = {
-      ...style,
-      ...context?.tooltip.style
-    };
-    const tooltipMode = currentMode === "dark" ? "light" : "dark";
-    useLayoutEffect(() => {
-      if (!childrenRef.current) return;
-      const focusElements = getKeyboardFocusableElements(childrenRef.current);
-      focusItems.current = focusElements;
-    }, [childrenRef, children, context?.open]);
-    useLayoutEffect(() => {
-      if (id) {
-        context?.tooltip.setId(id);
-      }
-    }, [id, context?.tooltip.setId, context?.tooltip]);
-    const onMouseEnterHandler = (e) => {
-      onMouseEnter?.(e);
-      if (context?.controlled) return;
-      context?.tooltip.show();
-    };
-    const onMouseLeaveHandler = (e) => {
-      onMouseLeave?.(e);
-      if (context?.controlled) return;
-      context?.tooltip.close();
-    };
-    const onFocusHandler = (e) => {
-      onFocus?.(e);
-      if (context?.controlled) return;
-      context?.tooltip.show();
-    };
-    const onBlurHandler = (e) => {
-      onBlur?.(e);
-      if (context?.controlled) return;
-      context?.tooltip.close();
-    };
-    const onKeyDownHandler = (e) => {
-      onKeyDown?.(e);
-      if (!context?.open) return;
-      if (e.code === "Escape") {
-        context?.tooltip.close();
-      }
-    };
-    const hasSimpleContent = typeof children === "string";
-    const role = hasSimpleContent ? "tooltip" : "region";
-    const tooltipWrapperRef = useMergeRefs([context?.tooltip.ref, ref]);
-    return /* @__PURE__ */ jsxs(
-      "div",
-      {
-        popover: context?.controlled ? "manual" : "auto",
-        "data-anv": "tooltip-content",
-        className: tooltipClassNames,
-        ref: tooltipWrapperRef,
-        style: combinedStyles,
-        onMouseEnter: onMouseEnterHandler,
-        onMouseLeave: onMouseLeaveHandler,
-        onBlur: onBlurHandler,
-        onFocus: onFocusHandler,
-        role,
-        id: context?.tooltip.id,
-        ...rest,
-        children: [
-          /* @__PURE__ */ jsx(
-            "div",
-            {
-              className: styles$4.scroller,
-              role: "presentation",
-              tabIndex: -1,
-              ref: childrenRef,
-              onKeyDown: onKeyDownHandler,
-              children: hasSimpleContent ? children : /* @__PURE__ */ jsx(ThemeProvider, { mode: tooltipMode, "data-anv": "tooltip-content-theme", children })
-            },
-            context?.tooltip.key
-          ),
-          /* @__PURE__ */ jsx("span", { className: styles$4["arrow"], ref: context?.tooltip.arrowRef, children: /* @__PURE__ */ jsxs("svg", { "aria-hidden": "true", width: "14", height: "14", viewBox: "0 0 14 14", children: [
-            /* @__PURE__ */ jsx("path", { stroke: "none", d: "M0,0 H14 L7,7 Q7,7 7,7 Z" }),
-            /* @__PURE__ */ jsx("clipPath", { id: ":r9:", children: /* @__PURE__ */ jsx("rect", { x: "0", y: "0", width: "14", height: "14" }) })
-          ] }) })
-        ]
-      }
-    );
-  }
-);
-const TooltipContent = forwardRef(
-  function TooltipContent3(props, ref) {
-    if (!supportsPopover())
-      return /* @__PURE__ */ jsx(TooltipLegacyContent, { ...props, ref });
-    return /* @__PURE__ */ jsx(TooltipContentElement, { ...props, ref });
-  }
-);
-
-const TooltipLegacyTrigger = forwardRef(function TooltipLegacyTrigger2({ children, className, ...props }, propRef) {
-  const context = useTooltipLegacyContext();
-  const ref = useMergeRefs([context.refs.setReference, propRef]);
-  const { "aria-describedby": ariaDescribedBy, ...restOfContextProps } = context.getReferenceProps(props);
-  const child = cloneElement(children, {
-    ref,
-    "aria-describedby": ariaDescribedBy
-  });
-  return /* @__PURE__ */ jsx(
-    "span",
-    {
-      ref,
-      className: cx([styles$3["trigger-legacy"]], className),
-      "data-anv": "tooltip-trigger",
-      "data-state": context.open ? "open" : "closed",
-      ...restOfContextProps,
-      children: child
-    }
-  );
-});
-
-const INTERACTIVE_ELEMENTS = ["button", "a", "input", "textarea", "select"];
-function isNonInteractiveElement(element) {
-  if (!isValidElement(element)) return false;
-  const type = element.type;
-  return typeof type === "string" && !INTERACTIVE_ELEMENTS.includes(type);
-}
-
-const TooltipTriggerElement = forwardRef(
-  function TooltipTrigger2(props, propRef) {
-    const { children, className, onKeyDown, onFocus, onBlur, ...rest } = props;
-    const context = useTooltipContext();
-    const childCanAcceptRef = useMemo(
-      () => isValidElement(children) && children.type !== Fragment$1 && typeof children.type !== "function",
-      [children]
-    );
-    const refs = useMergeRefs([children?.ref, context?.invoker.ref]);
-    const childProps = useMemo(() => {
-      const baseProps = {
-        ref: refs,
-        "aria-haspopup": context?.invoker["aria-haspopup"],
-        "aria-details": context?.invoker["aria-details"],
-        "data-state": context?.invoker["data-state"],
-        "aria-describedby": context?.invoker["aria-describedby"]
-      };
-      if (isNonInteractiveElement(children)) {
-        if (!("tabIndex" in (children.props || {}))) {
-          baseProps.tabIndex = 0;
-        }
-        if (!("role" in (children.props || {}))) {
-          baseProps.role = "button";
-        }
-      }
-      return baseProps;
-    }, [context?.invoker, refs, children]);
-    const child = childCanAcceptRef ? cloneElement(children, childProps) : /* @__PURE__ */ jsx("span", { ...childProps, children });
-    const onKeyDownHandler = (e) => {
-      onKeyDown?.(e);
-      context?.invoker.onKeyDown(e);
-    };
-    const onFocusHandler = (e) => {
-      onFocus?.(e);
-      context?.invoker.onFocus();
-    };
-    const onBlurHandler = (e) => {
-      onBlur?.(e);
-      context?.invoker.onBlur();
-    };
-    useLayoutEffect(() => {
-      const onMouseEnterHandler = () => {
-        context?.invoker.onMouseEnter();
-      };
-      const onMouseLeaveHandler = () => {
-        context?.invoker.onMouseLeave();
-      };
-      context?.invoker.ref.current?.addEventListener(
-        "mouseleave",
-        onMouseLeaveHandler
-      );
-      context?.invoker.ref.current?.addEventListener(
-        "mouseenter",
-        onMouseEnterHandler
-      );
-      return () => {
-        context?.invoker.ref.current?.removeEventListener(
-          "mouseleave",
-          onMouseLeaveHandler
-        );
-        context?.invoker.ref.current?.removeEventListener(
-          "mouseenter",
-          onMouseEnterHandler
-        );
-      };
-    }, [context?.invoker]);
-    if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacyTrigger, { ...props });
-    return /* @__PURE__ */ jsx(
-      "span",
-      {
-        className: cx([styles$4["trigger"]], className),
-        "data-anv": "tooltip-trigger",
-        ref: propRef,
-        onKeyDown: onKeyDownHandler,
-        onFocus: onFocusHandler,
-        onBlur: onBlurHandler,
-        role: "presentation",
-        ...rest,
-        children: child
-      }
-    );
-  }
-);
-const TooltipTrigger = forwardRef(
-  function TooltipTrigger3(props, propRef) {
-    if (!supportsPopover())
-      return /* @__PURE__ */ jsx(TooltipLegacyTrigger, { ...props, ref: propRef });
-    return /* @__PURE__ */ jsx(TooltipTriggerElement, { ...props, ref: propRef });
-  }
-);
-
-function useTooltipLegacy({
-  defaultOpen = false,
-  offset: offsetProp = 5,
-  open: controlledOpen,
-  placement = "top",
-  fallbackPlacements,
-  disableFlip,
-  disableShift,
-  root
-} = {}) {
-  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);
-  const open = controlledOpen ?? uncontrolledOpen;
-  const setOpen = setUncontrolledOpen;
-  const { disableDelayGroup } = useTooltipLegacyGroup();
-  useEffect(() => {
-    if (!defaultOpen && !controlledOpen) {
-      disableDelayGroup(true);
-    }
-    disableDelayGroup(false);
-  }, [defaultOpen, controlledOpen, disableDelayGroup]);
-  const arrowRef = useRef(null);
-  const { delay } = useDelayGroupContext();
-  const data = useFloating({
-    placement,
-    open,
-    onOpenChange: setOpen,
-    whileElementsMounted: autoUpdate,
-    middleware: [
-      offset(offsetProp),
-      flip({
-        crossAxis: !disableFlip ? placement.includes("-") : false,
-        mainAxis: !disableFlip,
-        fallbackAxisSideDirection: "start",
-        fallbackPlacements,
-        padding: 5
-      }),
-      shift({
-        padding: 5,
-        mainAxis: !disableShift,
-        crossAxis: false,
-        limiter: limitShift({
-          mainAxis: !disableShift
-        })
-      }),
-      arrow$1({ element: arrowRef, padding: 5 })
-    ]
-  });
-  const context = data.context;
-  const hover = useHover(context, {
-    move: false,
-    handleClose: safePolygon(),
-    delay
-  });
-  const focus = useFocus(context, {});
-  const dismiss = useDismiss(context);
-  const role = useRole(context, { role: "tooltip" });
-  const interactions = useInteractions([hover, focus, dismiss, role]);
-  return useMemo(
-    () => ({
-      open,
-      setOpen,
-      arrowRef,
-      root,
-      ...interactions,
-      ...data
-    }),
-    [open, setOpen, interactions, data, root]
-  );
-}
-
-function TooltipLegacyElement({
-  children,
-  ...options
-}) {
-  const tooltip = useTooltipLegacy(options);
-  const { theme, mode } = useContext(ThemeProviderContext);
-  const value = useMemo(
-    () => ({ ...tooltip, theme, mode }),
-    [mode, theme, tooltip]
-  );
-  return /* @__PURE__ */ jsx(TooltipLegacyContext.Provider, { value, children });
-}
-const TooltipLegacy = Object.assign(TooltipLegacyElement, {
-  Trigger: TooltipLegacyTrigger,
-  Content: TooltipLegacyContent
-});
-
-const TooltipElement = (props) => {
-  const {
-    children,
-    delay = 100,
-    placement = "top",
-    open,
-    defaultOpen = false,
-    disableShift,
-    disableFlip,
-    disableFlipFallback,
-    id,
-    offset: offsetProp = 5,
-    fallbackPlacements,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    root
-  } = props;
-  const uid = useId();
-  const [invoker, setInvoker] = useState(void 0);
-  const [tooltip, setTooltip] = useState(void 0);
-  const [rootNode, setRootNode] = useState();
-  const [arrowElement, setArrowElement] = useState(void 0);
-  const [openState, setOpenState] = useState(
-    open ?? defaultOpen
-  );
-  const arrowRef = useRef(null);
-  const [tooltipId, setTooltipId] = useState(
-    id ?? `tooltip-${uid.replace(/:/g, "")}`
-  );
-  const updatePosition = useCallback(() => {
-    if (!invoker || !tooltip) return;
-    if (!openState) return;
-    computePosition(invoker, tooltip, {
-      placement,
-      middleware: [
-        offset(offsetProp),
-        flip({
-          mainAxis: !disableFlip,
-          crossAxis: false,
-          fallbackAxisSideDirection: disableFlipFallback ? "none" : "end",
-          fallbackPlacements,
-          padding: 5
-        }),
-        shift({
-          padding: 5,
-          mainAxis: !disableShift,
-          crossAxis: false,
-          limiter: limitShift({
-            mainAxis: !disableShift
-          })
-        }),
-        arrow$1({
-          element: arrowElement ? arrowElement : null,
-          padding: 5
-        })
-      ]
-    }).then(({ x, y, placement: placement2, middlewareData }) => {
-      const side = placement2.split("-")[0];
-      const staticSide = {
-        top: "bottom",
-        right: "left",
-        bottom: "top",
-        left: "right"
-      }[side];
-      const arrowDeg = () => {
-        if (staticSide === "top") return 180;
-        if (staticSide === "bottom") return 0;
-        if (staticSide === "left") return 90;
-        return 270;
-      };
-      Object.assign(tooltip.style, {
-        left: `${x}px`,
-        top: `${y}px`
-      });
-      if (middlewareData.arrow && arrowElement) {
-        const { x: x2, y: y2 } = middlewareData.arrow;
-        Object.assign(arrowElement.style, {
-          left: x2 != null ? `${x2}px` : "",
-          top: y2 != null ? `${y2}px` : "",
-          right: "",
-          bottom: "",
-          [staticSide]: `${-arrowElement.offsetWidth + 2}px`,
-          transform: `rotate(${arrowDeg()}deg)`
-        });
-      }
-    });
-  }, [
-    invoker,
-    tooltip,
-    openState,
-    placement,
-    offsetProp,
-    disableFlip,
-    disableFlipFallback,
-    fallbackPlacements,
-    disableShift,
-    arrowElement
-  ]);
-  const resetKey = useRef(0);
-  useLayoutEffect(() => {
-    if (!tooltip || !invoker) return;
-    if (!openState) {
-      resetKey.current += 1;
-      return;
-    }
-    let requestID = null;
-    const cleanup = autoUpdate(invoker, tooltip, () => {
-      requestID = requestAnimationFrame(updatePosition);
-    });
-    return () => {
-      if (requestID) cancelAnimationFrame(requestID);
-      cleanup();
-    };
-  }, [invoker, tooltip, updatePosition, openState]);
-  const isControlled = typeof open !== "undefined";
-  const openTimeoutRef = useRef(null);
-  const closeTimeoutRef = useRef(null);
-  const openTooltip = useCallback(() => {
-    clearTimeout(closeTimeoutRef.current);
-    clearTimeout(openTimeoutRef.current);
-    if (!tooltip || !rootNode?.querySelector(`#${tooltipId}`)) return;
-    openTimeoutRef.current = setTimeout(() => {
-      safeShowPopover(tooltip);
-      setOpenState(true);
-    }, delay);
-  }, [tooltip, rootNode, tooltipId, delay]);
-  const closeTooltip = useCallback(
-    (fn) => {
-      clearTimeout(openTimeoutRef.current);
-      clearTimeout(closeTimeoutRef.current);
-      if (!tooltip || !openState) return;
-      closeTimeoutRef.current = setTimeout(() => {
-        fn?.();
-        setOpenState(false);
-        safeHidePopover(tooltip);
-      }, 100);
-    },
-    [openState, tooltip]
-  );
-  const initialRender = useRef(true);
-  useEffect(() => {
-    if (initialRender.current === true) {
-      if (openState) openTooltip();
-      initialRender.current = false;
-      return;
-    }
-  }, [openTooltip, openState, isControlled]);
-  useEffect(() => {
-    if (!isControlled) return;
-    if (open) {
-      openTooltip();
-    } else {
-      closeTooltip();
-    }
-  }, [closeTooltip, isControlled, open, openTooltip]);
-  const value = useMemo(() => {
-    updatePosition();
-    return {
-      tooltipId,
-      setTooltipId,
-      invoker,
-      setInvoker,
-      tooltip,
-      setTooltip,
-      arrowElement,
-      setArrowElement,
-      openTooltip,
-      closeTooltip,
-      placement,
-      openState,
-      setOpenState,
-      disableFlipFallback,
-      controlled: isControlled,
-      arrowRef,
-      resetKey: resetKey.current,
-      rootNode,
-      setRootNode
-    };
-  }, [
-    updatePosition,
-    tooltipId,
-    setTooltipId,
-    invoker,
-    tooltip,
-    arrowElement,
-    openTooltip,
-    closeTooltip,
-    placement,
-    openState,
-    disableFlipFallback,
-    isControlled,
-    rootNode
-  ]);
-  if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacy, { ...props });
-  return /* @__PURE__ */ jsx(TooltipContext.Provider, { value, children });
-};
-const Tooltip = Object.assign(TooltipElement, {
-  /**
-   * TooltipTrigger component that wraps the element that triggers the tooltip.
-   *
-   * Features:
-   * - Wraps any React element to make it a tooltip trigger
-   * - Handles mouse and keyboard interactions
-   * - Provides proper ARIA attributes for accessibility
-   * - Supports all standard HTML element props
-   * - Automatically clones child elements with proper refs
-   * - Handles both focusable and non-focusable children
-   * - Manages mouse enter/leave events for hover behavior
-   *
-   * @example
-   * <Tooltip.Trigger>
-   *   <Button>Click me</Button>
-   * </Tooltip.Trigger>
-   */
-  Trigger: TooltipTrigger,
-  /**
-   * TooltipContent component that displays the tooltip content.
-   *
-   * Features:
-   * - Displays the tooltip content with proper positioning
-   * - Includes an arrow pointing to the trigger element
-   * - Supports keyboard navigation and escape key to close
-   * - Handles mouse interactions for hover behavior
-   * - Accessible with proper ARIA roles
-   * - Supports all standard div element props
-   * - Automatic focus management for keyboard navigation
-   * - Real-time position updates
-   * - Handles both string and complex content
-   *
-   * @example
-   * <Tooltip.Content>
-   *   This tooltip provides helpful context
-   * </Tooltip.Content>
-   */
-  Content: TooltipContent,
-  Context: TooltipContext
-});
-
-const LabelMoreInfoIcon = ({
-  moreInfo,
-  openMoreInfo
-}) => {
-  const [open, setOpen] = useState(openMoreInfo);
-  useEffect(() => {
-    if (openMoreInfo) {
-      setOpen(true);
-    } else {
-      setOpen(false);
-      setTimeout(() => {
-        setOpen(void 0);
-      });
-    }
-  }, [openMoreInfo]);
-  return /* @__PURE__ */ jsxs(
-    Tooltip,
-    {
-      open,
-      placement: "top",
-      offset: 5,
-      fallbackPlacements: ["right", "bottom", "left"],
-      children: [
-        /* @__PURE__ */ jsx(Tooltip.Trigger, { className: styles$5["info-trigger"], children: /* @__PURE__ */ jsx(Icon, { svg: SvgInfo }) }),
-        /* @__PURE__ */ jsx(Tooltip.Content, { className: styles$5["info-content"], children: moreInfo })
-      ]
-    }
-  );
-};
-const Label = forwardRef((props, ref) => {
-  const { children, className, moreInfo, required, openMoreInfo, ...rest } = props;
-  const LabelClassNames = cx([styles$5["label"]], className);
-  return /* @__PURE__ */ jsxs("label", { className: LabelClassNames, "data-anv": "label", ref, ...rest, children: [
-    /* @__PURE__ */ jsxs("div", { className: styles$5["top-container"], "aria-atomic": "true", children: [
-      /* @__PURE__ */ jsxs("span", { className: styles$5["label-text"], children: [
-        children,
-        required ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx("span", { "aria-hidden": true, className: styles$5["required"], children: "*" }),
-          /* @__PURE__ */ jsx(SrOnly, { children: "Required" })
-        ] }) : null
-      ] }),
-      moreInfo ? /* @__PURE__ */ jsx(LabelMoreInfoIcon, { moreInfo, openMoreInfo }) : null
-    ] }),
-    moreInfo ? /* @__PURE__ */ jsx(SrOnly, { children: moreInfo }) : null
-  ] });
-});
-Label.displayName = "Label";
-
-const bar = "_bar_1lj98_23";
-const indeterminate = "_indeterminate_1lj98_1";
-const success = "_success_1lj98_66";
-const error = "_error_1lj98_52";
-const styles = {
-	"progress-bar": "_progress-bar_1lj98_2",
-	"bar-container": "_bar-container_1lj98_23",
-	bar: bar,
-	"check-icon": "_check-icon_1lj98_49",
-	"error-icon": "_error-icon_1lj98_52",
-	indeterminate: indeterminate,
-	success: success,
-	error: error
-};
-
-const ProgressBar = forwardRef(
-  (props, ref) => {
-    const { layoutStyles, componentProps } = useLayoutPropsUtil(props);
-    const {
-      className,
-      style,
-      value,
-      children,
-      indeterminate,
-      errorAriaLive,
-      description,
-      error = false,
-      max = 100,
-      ...mainProps
-    } = componentProps;
-    const styleCombined = {
-      ...style,
-      ...layoutStyles
-    };
-    const errorMessage = typeof error !== "boolean" ? error : void 0;
-    const labelUid = useId();
-    const isSuccess = typeof value !== "undefined" && +value === +max;
-    if ("label" in props && !!props.label) {
-      const { label, labelProps, ...rest } = mainProps;
-      const ProgressBarClassNames2 = cx(
-        [styles["progress-bar"]],
-        className,
-        {
-          [styles[`error`]]: error,
-          [styles[`success`]]: isSuccess
-        }
-      );
-      return /* @__PURE__ */ jsxs(
-        "div",
-        {
-          className: ProgressBarClassNames2,
-          "data-anv": "progress-bar",
-          style: styleCombined,
-          ref,
-          children: [
-            /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", children: [
-              /* @__PURE__ */ jsx(Label, { id: labelUid, ...labelProps, children: label }),
-              isSuccess && !error ? /* @__PURE__ */ jsx(Icon, { className: styles["check-icon"], svg: SvgCheckCircle }) : null,
-              error ? /* @__PURE__ */ jsx(Icon, { className: styles["error-icon"], svg: SvgError }) : null
-            ] }),
-            /* @__PURE__ */ jsx("div", { className: styles["bar-container"], children: /* @__PURE__ */ jsx(
-              "progress",
-              {
-                "aria-labelledby": labelUid,
-                className: styles["bar"],
-                value,
-                max,
-                ...rest
-              }
-            ) }),
-            errorMessage || description ? /* @__PURE__ */ jsx(
-              Helper,
-              {
-                errorMessage,
-                errorAriaLive,
-                description
-              }
-            ) : null
-          ]
-        }
-      );
-    }
-    const ProgressBarClassNames = cx([styles["progress-bar"]], className, {
-      [styles[`error`]]: error,
-      [styles[`success`]]: isSuccess
-    });
-    return /* @__PURE__ */ jsxs(
-      "div",
-      {
-        className: ProgressBarClassNames,
-        "data-anv": "progress-bar",
-        style: styleCombined,
-        ref,
-        children: [
-          /* @__PURE__ */ jsx("div", { className: styles["bar-container"], children: /* @__PURE__ */ jsx(
-            "progress",
-            {
-              className: styles["bar"],
-              max,
-              value,
-              ...mainProps
-            }
-          ) }),
-          errorMessage || description ? /* @__PURE__ */ jsx(
-            Helper,
-            {
-              errorMessage,
-              errorAriaLive,
-              description
-            }
-          ) : null
-        ]
-      }
-    );
-  }
-);
-ProgressBar.displayName = "ProgressBar";
-
-export { DrawerCancelButton as D, Label as L, ProgressBar as P, TooltipTrigger as T, DrawerFooter as a, DrawerHeader as b, DrawerContent as c, Drawer as d, TooltipContent as e, Tooltip as f, getActiveElement as g, Toaster as h, DialogContext as i, useDialogTransitionStates as j, useDialogScrollLock as k, useOnClickOutside as l, ToastProvider as m, ToasterPopover as n, ToasterContent as o, DrawerContext as p, safeShowPopover as q, safeHidePopover as r, supportsPopover as s, toast as t, useKeyboardFocusables as u, useOpenCloseTransitionStates as v };
-//# sourceMappingURL=ProgressBar-BRvB-bD4-DppwBrFg.js.map