@servicetitan/anvil2 1.30.0 → 1.31.1

package/dist/ProgressBar-C5jHU322-BUKq_wDl.js

@@ -0,0 +1,2544 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { useState, useRef, useEffect, forwardRef, useId, useContext, createContext, useCallback, useMemo, cloneElement, useLayoutEffect } from 'react';
+import { c as cx } from './index-tZvMCc77.js';
+import { I as Icon } from './Icon-DuwR7O2z-DwPHQiBF.js';
+import { a as SvgCheckCircle, S as SvgError, b as SvgInfo } from './check_circle-BGfigqq-.js';
+import { t as tabbable, q 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, r as useDelayGroupContext, c as useFloating, h as useHover, i as safePolygon, v as useFocus, j as useDismiss, k as useRole, m as useInteractions } from './floating-ui.react-Domgunz0.js';
+import { a as PortalProviderContext } from './PortalProvider-9lXkQ0xY-BKoGegS1.js';
+import { S as SvgClose } from './close-DZj38AEh.js';
+import { T as Text } from './Text-BCRKWTMM-BvIdEgVR.js';
+import { B as Button } from './Button-CpDA5JHI-DOaf7xjY.js';
+import { A as Alert } from './Alert-BW0jYz7s-C_bALro8.js';
+import { F as Flex } from './Flex-DlNiHX1G-DiUzqGqj.js';
+import { u as useLayoutPropsUtil } from './useLayoutPropsUtil-3B2XYWSr-ChuzrydG.js';
+import { H as Helper } from './Helper-DBmwQvEP-Z2T8bXHx.js';
+import { u as useSwipe } from './useSwipe-DIUHs7T5-DIUHs7T5.js';
+import { S as SrOnly } from './SrOnly-BXm1DGl3-BJVodjQp.js';
+import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
+import { T as ThemeProvider, a as ThemeProviderContext } from './ThemeProvider-DrK12Ru--D1_n9ujr.js';
+import { g as getKeyboardFocusableElements } from './getKeyboardFocusableElements-QqcABz0D.js';
+import { u as useTooltipLegacyGroup } from './HammerProvider-C9QySDSZ-CLRb96CM.js';
+
+import './ProgressBar-C5jHU322.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 dialog = "_dialog_1uzo4_3";
+const container$1 = "_container_1uzo4_23";
+const content$2 = "_content_1uzo4_36";
+const header$1 = "_header_1uzo4_43";
+const footer$1 = "_footer_1uzo4_63";
+const large$1 = "_large_1uzo4_100";
+const fullscreen = "_fullscreen_1uzo4_100";
+const sticky$1 = "_sticky_1uzo4_119";
+const styles$6 = {
+	dialog: dialog,
+	container: container$1,
+	content: content$2,
+	header: header$1,
+	"close-container": "_close-container_1uzo4_56",
+	footer: footer$1,
+	large: large$1,
+	fullscreen: fullscreen,
+	sticky: sticky$1,
+	"close-button": "_close-button_1uzo4_125"
+};
+
+const DialogCancelButton = forwardRef((props, ref) => {
+  const { onClick, ...rest } = props;
+  const { close } = useDialogContext();
+  const onClickHandler = (e) => {
+    onClick?.(e);
+    close();
+  };
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      "aria-label": "Close dialog",
+      "data-anv": "dialog-cancel-button",
+      onClick: onClickHandler,
+      ref,
+      ...rest
+    }
+  );
+});
+DialogCancelButton.displayName = "DialogCancelButton";
+
+const DialogHeader = forwardRef(
+  (props, ref) => {
+    const { children, className, ...rest } = props;
+    const headerClassNames = cx(className, styles$6["header"]);
+    return /* @__PURE__ */ jsxs(
+      "header",
+      {
+        className: headerClassNames,
+        "data-anv": "dialog-header",
+        ref,
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx(Text, { variant: "headline", el: "h1", children }),
+          /* @__PURE__ */ jsx("span", { className: styles$6["close-container"], children: /* @__PURE__ */ jsx(
+            DialogCancelButton,
+            {
+              className: styles$6["close-button"],
+              size: "small",
+              appearance: "ghost",
+              "aria-label": "Close dialog",
+              icon: SvgClose
+            }
+          ) })
+        ]
+      }
+    );
+  }
+);
+DialogHeader.displayName = "DialogHeader";
+
+const DialogFooter = forwardRef(
+  (props, ref) => {
+    const { children, className, sticky = false, ...rest } = props;
+    const footerClassNames = cx(styles$6["footer"], className, {
+      [styles$6["sticky"]]: sticky
+    });
+    return /* @__PURE__ */ jsx(
+      "footer",
+      {
+        className: footerClassNames,
+        "data-anv": "dialog-footer",
+        ref,
+        ...rest,
+        children
+      }
+    );
+  }
+);
+DialogFooter.displayName = "DialogFooter";
+
+const DialogContent = forwardRef(
+  (props, ref) => {
+    const { children, className, ...rest } = props;
+    const contentClassNames = cx(styles$6["content"], className);
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: contentClassNames,
+        "data-anv": "dialog-content",
+        ref,
+        ...rest,
+        children
+      }
+    );
+  }
+);
+DialogContent.displayName = "DialogContent";
+
+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_lombm_3";
+const toaster = "_toaster_lombm_10";
+const hidden = "_hidden_lombm_25";
+const stacked = "_stacked_lombm_89";
+const open = "_open_lombm_184";
+const close = "_close_lombm_185";
+const styles$5 = {
+	popover: popover,
+	toaster: toaster,
+	hidden: hidden,
+	"toast-stack": "_toast-stack_lombm_28",
+	"toast-wrapper": "_toast-wrapper_lombm_45",
+	"toast-alert": "_toast-alert_lombm_59",
+	"alert-action": "_alert-action_lombm_64",
+	"message-container": "_message-container_lombm_70",
+	"show-extra-toast": "_show-extra-toast_lombm_79",
+	stacked: stacked,
+	"stack-one": "_stack-one_lombm_92",
+	"stack-two": "_stack-two_lombm_92",
+	"stacked-show-extra": "_stacked-show-extra_lombm_108",
+	"stacked-extra": "_stacked-extra_lombm_122",
+	"show-more-button-container": "_show-more-button-container_lombm_135",
+	"show-collapse-button-container": "_show-collapse-button-container_lombm_136",
+	"show-collapse-button": "_show-collapse-button_lombm_136",
+	"disable-animations": "_disable-animations_lombm_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$5.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$5.hidden
+    );
+    const [toastOpened, setToastOpened] = useState(false);
+    const duration = actions ? false : durationProp;
+    const alertClasses = cx(
+      styles$5["toast-alert"],
+      toastClassName,
+      transitionClass
+    );
+    useEffect(() => {
+      if (!toastOpened) {
+        setTransitionClass(styles$5.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$5["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$5["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 = document.activeElement?.shadowRoot?.activeElement || document.activeElement;
+      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$5["toast-stack"], className, {
+      [styles$5["show-more-button"]]: showMoreButton,
+      [styles$5["show-extra-toast"]]: extraToastsVisible,
+      [styles$5["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);
+    };
+    const toastStackHeightStyle = extraToastsVisible ? "calc(100vh - var(--toast-stack-padding) * 2)" : toastCount > 0 ? `calc(${toastStackHeight}px + 2rem + var(--toast-stack-padding))` : 0;
+    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$5.toast, toastClassName);
+              const toastContainerClasses = cx(styles$5["toast-wrapper"], {
+                [styles$5.stacked]: isStacked || isLastToastDisplayed,
+                [styles$5["stack-one"]]: isStacked && index === toastCount - toastsBeforeStack - 1,
+                [styles$5["stack-two"]]: isStacked && index === toastCount - toastsBeforeStack - 2,
+                [styles$5["stacked-extra"]]: isHidden,
+                [styles$5["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$5["show-more-button-container"],
+                style: showMoreButtonPositionStyles,
+                children: /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    className: styles$5["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$5["show-collapse-button-container"], children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: styles$5["show-collapse-button"],
+          onClick: handleToastStackBlur,
+          appearance: "secondary",
+          children: "Collapse Messages"
+        }
+      ) })
+    ] });
+  }
+);
+ToastStack.displayName = "ToastStack";
+
+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;
+      const currentPopover = popoverRef.current;
+      let timeout;
+      if (toastCount > 0) {
+        if (isDialogToaster) {
+          timeout = setTimeout(() => {
+            currentPopover?.hidePopover();
+            currentPopover?.showPopover();
+          });
+        } else {
+          currentPopover.showPopover();
+        }
+      } else {
+        currentPopover.hidePopover();
+      }
+      return () => {
+        if (timeout) clearTimeout(timeout);
+        if (toastCount === 0) {
+          currentPopover.hidePopover();
+        }
+      };
+    }, [toastCount, isDialogToaster]);
+    return /* @__PURE__ */ jsx("div", { ref: combinedRef, className: styles$5.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$5.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$5.toaster, {
+      [styles$5["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 DialogContext = createContext(null);
+const DialogElement = forwardRef(
+  (props, ref) => {
+    const {
+      className,
+      open = false,
+      children,
+      onOpen,
+      onOpenChange,
+      onClose,
+      onCancel,
+      onKeyDown,
+      fullScreen = false,
+      disableCloseOnEscape = false,
+      disableCloseOnClickOutside = false,
+      size,
+      enableScrollChaining,
+      ...rest
+    } = props;
+    const elRef = useRef(null);
+    const contentRef = useRef(null);
+    const [hasOpenPopover, setHasOpenPopover] = useState(false);
+    const id = useId();
+    const DialogClassNames = cx([styles$6["dialog"]], className, {
+      [styles$6["fullscreen"]]: fullScreen,
+      [styles$6["large"]]: size === "large"
+    });
+    const { focusables } = useKeyboardFocusables(contentRef, {
+      observeChange: true
+    });
+    useEffect(() => {
+      if (!open || enableScrollChaining) return;
+      let blockDocumentScroll = false;
+      const content = contentRef.current;
+      const scrollHandler = (e) => {
+        const target = e.target;
+        const isShadow2 = contentRef.current?.getRootNode() instanceof ShadowRoot;
+        const isOverflowing = elRef.current && elRef.current.scrollHeight > elRef.current.clientHeight;
+        if (isShadow2) {
+          if (blockDocumentScroll) {
+            e.preventDefault();
+            return;
+          }
+          return;
+        }
+        if (!isOverflowing || !content?.contains(target)) {
+          e.preventDefault();
+          return;
+        }
+        return;
+      };
+      const shadowScrollHandler = (e) => {
+        const target = e.target;
+        const isTargetInsideContent = content?.contains(target);
+        const isOverflowing = elRef.current && elRef.current.scrollHeight > elRef.current.clientHeight;
+        blockDocumentScroll = !isTargetInsideContent;
+        if (!isOverflowing || !content?.contains(target)) {
+          e.preventDefault();
+        }
+        return;
+      };
+      const isShadow = content?.getRootNode() instanceof ShadowRoot;
+      document.addEventListener("wheel", scrollHandler, {
+        passive: false
+      });
+      if (isShadow) {
+        content?.getRootNode().addEventListener("wheel", shadowScrollHandler, {
+          passive: false
+        });
+      }
+      return () => {
+        document.getRootNode().removeEventListener("wheel", scrollHandler);
+        if (isShadow) {
+          content?.getRootNode().removeEventListener("wheel", shadowScrollHandler);
+        }
+      };
+    }, [enableScrollChaining, open]);
+    useEffect(() => {
+      if (typeof document === "undefined" || disableCloseOnClickOutside) return;
+      const onClickOutsideHandler = (e) => {
+        if (hasOpenPopover) return;
+        if (e.composedPath()[0] === elRef.current) {
+          onClose?.();
+        }
+      };
+      document.addEventListener("mousedown", onClickOutsideHandler);
+      return () => document.removeEventListener("mousedown", onClickOutsideHandler);
+    }, [disableCloseOnClickOutside, onClose, onOpenChange, hasOpenPopover]);
+    const initial = useRef(true);
+    useEffect(() => {
+      if (initial.current) {
+        initial.current = false;
+      } else {
+        onOpenChange?.(open);
+      }
+      if (open) {
+        onOpen?.();
+        elRef.current?.showModal();
+        return;
+      }
+      setTimeout(() => {
+        elRef.current?.close();
+      }, 1);
+    }, [id, onOpen, onOpenChange, open]);
+    useEffect(() => {
+      if (!open) return;
+      if (!focusables) return;
+      const activeElement = document.activeElement;
+      if (activeElement.dataset.anv !== "dialog-header-close-button" && focusables.includes(activeElement)) {
+        return;
+      }
+      if (focusables[0]?.dataset.anv === "dialog-header-close-button" && focusables[1]) {
+        focusables[1].focus();
+      } else {
+        focusables[0]?.focus();
+      }
+    }, [open, focusables]);
+    const onKeyDownHandler = (e) => {
+      onKeyDown?.(e);
+      if (e.code === "Escape") {
+        e.preventDefault();
+        if (disableCloseOnEscape) return;
+        if (hasOpenPopover) return;
+        onClose?.();
+        return;
+      }
+      if (e.code === "Tab") {
+        if (e.shiftKey && e.target === focusables?.[0]) {
+          e.preventDefault();
+          focusables[focusables.length - 1]?.focus();
+          return;
+        }
+        if (e.target === focusables?.[focusables.length - 1] && !e.shiftKey) {
+          e.preventDefault();
+          focusables[0].focus();
+          return;
+        }
+      }
+    };
+    const close = useCallback(() => {
+      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: DialogClassNames,
+          "data-anv": "dialog",
+          ref: useMergeRefs([ref, elRef]),
+          onKeyDown: onKeyDownHandler,
+          ...rest,
+          children: [
+            /* @__PURE__ */ jsx(ToastProvider, { isDialogToaster: open, children: /* @__PURE__ */ jsx(ToasterPopover, { children: /* @__PURE__ */ jsx(ToasterContent, { id: "dialog-toaster" }) }) }),
+            /* @__PURE__ */ jsx(
+              DialogContext.Provider,
+              {
+                value: { close, ref: elRef, hasOpenPopover, setHasOpenPopover },
+                children: /* @__PURE__ */ jsx(
+                  "section",
+                  {
+                    ref: contentRef,
+                    className: styles$6["container"],
+                    "data-open": open,
+                    children
+                  }
+                )
+              }
+            )
+          ]
+        }
+      )
+    );
+  }
+);
+function useDialogContext() {
+  const context = useContext(DialogContext);
+  if (!context) {
+    throw new Error(
+      "useDialogContext must be used within a DialogContextProvider"
+    );
+  }
+  return context;
+}
+DialogElement.displayName = "Dialog";
+const Dialog = Object.assign(DialogElement, {
+  Header: DialogHeader,
+  Footer: DialogFooter,
+  Content: DialogContent,
+  CancelButton: DialogCancelButton
+});
+
+const drawer = "_drawer_pysn1_3";
+const container = "_container_pysn1_29";
+const content$1 = "_content_pysn1_42";
+const header = "_header_pysn1_49";
+const footer = "_footer_pysn1_73";
+const remove = "_remove_pysn1_91";
+const large = "_large_pysn1_100";
+const sticky = "_sticky_pysn1_103";
+const styles$4 = {
+	drawer: drawer,
+	container: container,
+	content: content$1,
+	header: header,
+	"close-container": "_close-container_pysn1_66",
+	footer: footer,
+	remove: remove,
+	large: large,
+	sticky: sticky,
+	"close-button": "_close-button_pysn1_109"
+};
+
+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 { children } = props;
+    return /* @__PURE__ */ jsxs("header", { className: styles$4.header, "data-anv": "drawer-header", ref, children: [
+      /* @__PURE__ */ jsx(Text, { variant: "headline", el: "h1", children }),
+      /* @__PURE__ */ jsx("span", { className: styles$4["close-container"], children: /* @__PURE__ */ jsx(
+        DrawerCancelButton,
+        {
+          className: styles$4["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 { children, sticky = false, ...rest } = props;
+    const DrawerFooterCX = cx(styles$4.footer, {
+      [styles$4["sticky"]]: sticky
+    });
+    return /* @__PURE__ */ jsx(
+      "footer",
+      {
+        className: DrawerFooterCX,
+        "data-anv": "drawer-footer",
+        ref,
+        ...rest,
+        children
+      }
+    );
+  }
+);
+DrawerFooter.displayName = "DrawerFooter";
+
+const DrawerContent = forwardRef(
+  (props, ref) => {
+    const { children, ...rest } = props;
+    const DrawerContentCX = cx(styles$4.content, {});
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: DrawerContentCX,
+        "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,
+      onCancel,
+      onClick,
+      onKeyDown,
+      disableCloseOnEscape = false,
+      disableCloseOnClickOutside = false,
+      size = "medium",
+      enableScrollChaining,
+      ...rest
+    } = props;
+    const elRef = useRef(null);
+    const contentRef = useRef(null);
+    const toasterRef = useRef(null);
+    const combinedRef = useMergeRefs([elRef, ref]);
+    const [remove, setRemove] = useState(false);
+    const DrawerClassNames = cx([styles$4.drawer], className, {
+      [styles$4.remove]: remove,
+      [styles$4.large]: size === "large"
+    });
+    const { focusables } = useKeyboardFocusables(contentRef, {
+      observeChange: false
+    });
+    const firstFocusable = focusables?.[0];
+    const lastFocusable = focusables?.[focusables.length - 1];
+    useEffect(() => {
+      if (open) {
+        onOpen?.();
+        elRef.current?.showModal();
+        return;
+      }
+      setRemove(true);
+      setTimeout(() => {
+        elRef.current?.close();
+        setRemove(false);
+      }, 200);
+    }, [onOpen, open]);
+    useEffect(() => {
+      if (!open) return;
+      if (!focusables) return;
+      const activeElement = document.activeElement;
+      if (activeElement.dataset.anv !== "drawer-header-close-button" && focusables.includes(activeElement)) {
+        return;
+      }
+      if (focusables[0]?.dataset.anv === "drawer-header-close-button" && focusables[1]) {
+        focusables[1].focus();
+      } else {
+        focusables[0]?.focus();
+      }
+    }, [open, focusables]);
+    useEffect(() => {
+      if (!open || enableScrollChaining) return;
+      let blockDocumentScroll = false;
+      const content = contentRef.current;
+      const scrollHandler = (e) => {
+        const target = e.target;
+        const isShadow2 = contentRef.current?.getRootNode() instanceof ShadowRoot;
+        const isOverflowing = elRef.current && elRef.current.scrollHeight > elRef.current.clientHeight;
+        if (isShadow2) {
+          if (blockDocumentScroll) {
+            e.preventDefault();
+            return;
+          }
+          return;
+        }
+        if (!isOverflowing || !content?.contains(target)) {
+          e.preventDefault();
+          return;
+        }
+        return;
+      };
+      const shadowScrollHandler = (e) => {
+        const target = e.target;
+        const isTargetInsideContent = content?.contains(target);
+        const isOverflowing = elRef.current && elRef.current.scrollHeight > elRef.current.clientHeight;
+        blockDocumentScroll = !isTargetInsideContent;
+        if (!isOverflowing || !content?.contains(target)) {
+          e.preventDefault();
+        }
+        return;
+      };
+      const isShadow = content?.getRootNode() instanceof ShadowRoot;
+      document.addEventListener("wheel", scrollHandler, {
+        passive: false
+      });
+      if (isShadow) {
+        content?.getRootNode().addEventListener("wheel", shadowScrollHandler, {
+          passive: false
+        });
+      }
+      return () => {
+        document.getRootNode().removeEventListener("wheel", scrollHandler);
+        if (isShadow) {
+          content?.getRootNode().removeEventListener("wheel", shadowScrollHandler);
+        }
+      };
+    }, [enableScrollChaining, open]);
+    const onCancelHandler = (e) => {
+      e.preventDefault();
+      if (disableCloseOnEscape) return;
+      onClose?.();
+    };
+    const onClickHandler = (e) => {
+      onClick?.(e);
+      const target = e.target;
+      if (!contentRef.current?.contains(target) && !toasterRef.current?.contains(target)) {
+        e.preventDefault();
+        if (disableCloseOnClickOutside) 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 value = useMemo(() => {
+      const close = () => {
+        setRemove(true);
+        setTimeout(() => {
+          elRef.current?.close();
+          onClose?.();
+        }, 200);
+      };
+      return { close };
+    }, [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: DrawerClassNames,
+          "data-anv": "drawer",
+          ref: combinedRef,
+          onCancel: onCancelHandler,
+          onClick: onClickHandler,
+          onKeyDown: onKeyDownHandler,
+          ...rest,
+          children: [
+            /* @__PURE__ */ jsx(ToastProvider, { isDialogToaster: open, children: /* @__PURE__ */ jsx(ToasterPopover, { children: /* @__PURE__ */ jsx(ToasterContent, { id: "drawer-toaster", ref: toasterRef }) }) }),
+            /* @__PURE__ */ jsx(DrawerContext.Provider, { value, children: /* @__PURE__ */ jsx(
+              "section",
+              {
+                ref: contentRef,
+                className: styles$4.container,
+                "data-open": open,
+                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: DrawerHeader,
+  Footer: DrawerFooter,
+  Content: DrawerContent,
+  CancelButton: DrawerCancelButton
+});
+
+function supportsPopover() {
+  return Object.prototype.hasOwnProperty.call(HTMLElement.prototype, "popover");
+}
+
+const label = "_label_iolth_3";
+const required = "_required_iolth_47";
+const styles$3 = {
+	label: label,
+	"top-container": "_top-container_iolth_38",
+	"label-text": "_label-text_iolth_43",
+	required: required,
+	"info-trigger": "_info-trigger_iolth_52",
+	"info-content": "_info-content_iolth_57"
+};
+
+const content = "_content_tjoaw_3";
+const scroller = "_scroller_tjoaw_30";
+const arrow = "_arrow_tjoaw_33";
+const trigger = "_trigger_tjoaw_39";
+const styles$2 = {
+	content: content,
+	scroller: scroller,
+	arrow: arrow,
+	trigger: trigger
+};
+
+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 = () => {
+    context?.openTooltip();
+  };
+  const onMouseLeaveHandler = () => {
+    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-expanded": context.openState,
+      "aria-details": context.tooltipId,
+      "data-state": context.openState ? "open" : "closed",
+      "aria-describedby": context.tooltipId
+    },
+    tooltip: {
+      ref: popoverRef,
+      element: context.popover,
+      id: context.tooltipId,
+      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
+  };
+}
+
+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$1 = {
+	"content-legacy": "_content-legacy_19gkz_4",
+	"arrow-legacy": "_arrow-legacy_19gkz_30",
+	"trigger-legacy": "_trigger-legacy_19gkz_33"
+};
+
+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$1["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$1["arrow-legacy"]
+              }
+            ),
+            props.children
+          ]
+        }
+      ) })
+    }
+  );
+});
+
+const TooltipContentElement = forwardRef(
+  function TooltipContent2(props, ref) {
+    const {
+      children,
+      className,
+      style,
+      onMouseEnter,
+      onMouseLeave,
+      onKeyDown,
+      onFocus,
+      onBlur,
+      ...rest
+    } = props;
+    const context = useTooltipContext();
+    const tooltipClassNames = cx(className, styles$2["content"]);
+    const childrenRef = useRef(null);
+    const focusItems = useRef();
+    const combinedStyles = {
+      ...style,
+      ...context?.tooltip.style
+    };
+    useLayoutEffect(() => {
+      if (!childrenRef.current) return;
+      const focusElements = getKeyboardFocusableElements(childrenRef.current);
+      focusItems.current = focusElements;
+    }, [childrenRef, children, context?.open]);
+    const onMouseEnterHandler = (e) => {
+      onMouseEnter?.(e);
+      context?.tooltip.show();
+    };
+    const onMouseLeaveHandler = (e) => {
+      onMouseLeave?.(e);
+      context?.tooltip.close();
+    };
+    const onFocusHandler = (e) => {
+      onFocus?.(e);
+      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 tooltipWrapperRef = useMergeRefs([context?.tooltip.ref, ref]);
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        popover: "manual",
+        id: context?.tooltip.id,
+        "data-anv": "tooltip-content",
+        className: tooltipClassNames,
+        ref: tooltipWrapperRef,
+        style: combinedStyles,
+        onMouseEnter: onMouseEnterHandler,
+        onMouseLeave: onMouseLeaveHandler,
+        onBlur: onBlurHandler,
+        onFocus: onFocusHandler,
+        role: "tooltip",
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: styles$2.scroller,
+              role: "presentation",
+              tabIndex: -1,
+              ref: childrenRef,
+              onKeyDown: onKeyDownHandler,
+              children
+            },
+            context?.tooltip.key
+          ),
+          /* @__PURE__ */ jsx("span", { className: styles$2["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$1["trigger-legacy"]], className),
+      "data-anv": "tooltip-trigger",
+      "data-state": context.open ? "open" : "closed",
+      ...restOfContextProps,
+      children: child
+    }
+  );
+});
+
+const TooltipTriggerElement = forwardRef(
+  function TooltipTrigger2(props, propRef) {
+    const {
+      children,
+      className,
+      onMouseEnter,
+      onMouseLeave,
+      onKeyDown,
+      onFocus,
+      onBlur,
+      ...rest
+    } = props;
+    const context = useTooltipContext();
+    const child = cloneElement(children, {
+      ref: context?.invoker.ref,
+      "aria-haspopup": context?.invoker["aria-haspopup"],
+      "aria-expanded": context?.invoker["aria-expanded"],
+      "aria-details": context?.invoker["aria-details"],
+      "data-state": context?.invoker["data-state"],
+      "aria-describedby": context?.invoker["aria-describedby"]
+    });
+    const onMouseEnterHandler = (e) => {
+      onMouseEnter?.(e);
+      context?.invoker.onMouseEnter();
+    };
+    const onMouseLeaveHandler = (e) => {
+      onMouseLeave?.(e);
+      context?.invoker.onMouseLeave();
+    };
+    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();
+    };
+    if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacyTrigger, { ...props });
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: cx([styles$2["trigger"]], className),
+        "data-anv": "tooltip-trigger",
+        ref: propRef,
+        onMouseEnter: onMouseEnterHandler,
+        onMouseLeave: onMouseLeaveHandler,
+        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 TooltipContext = createContext(null);
+const TooltipElement = (props) => {
+  const {
+    children,
+    delay = 100,
+    placement = "top",
+    open,
+    defaultOpen = false,
+    disableShift,
+    disableFlip,
+    disableFlipFallback,
+    id,
+    offset: offsetProp = 5,
+    fallbackPlacements,
+    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 dialogContext = useContext(DialogContext);
+  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 () => {
+      requestID && cancelAnimationFrame(requestID);
+      cleanup();
+    };
+  }, [invoker, tooltip, updatePosition, openState]);
+  const popoverHoverTriggered = useRef();
+  const openTooltip = useCallback(async () => {
+    popoverHoverTriggered.current = true;
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    if (!popoverHoverTriggered.current || !tooltip || !rootNode?.querySelector(`#${id ?? `tooltip-${uid.replace(/:/g, "")}`}`))
+      return;
+    tooltip.showPopover();
+    setOpenState(true);
+    dialogContext?.setHasOpenPopover?.(true);
+  }, [tooltip, rootNode, id, uid, dialogContext, delay]);
+  const closeTooltip = useCallback(
+    async (fn) => {
+      popoverHoverTriggered.current = false;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      if (popoverHoverTriggered.current || !tooltip || !openState) return;
+      fn?.();
+      setOpenState(false);
+      tooltip?.hidePopover();
+      dialogContext?.setHasOpenPopover?.(false);
+    },
+    [tooltip, openState, dialogContext]
+  );
+  const isControlled = typeof open !== "undefined";
+  const initialRender = useRef(true);
+  useEffect(() => {
+    if (!isControlled) return;
+    if (initialRender.current === true) {
+      open && tooltip && openTooltip();
+      initialRender.current = false;
+      return;
+    }
+    setOpenState(open);
+    open ? openTooltip() : closeTooltip();
+  }, [closeTooltip, isControlled, open, openTooltip, tooltip]);
+  const value = useMemo(() => {
+    updatePosition();
+    return {
+      tooltipId: id ?? `tooltip-${uid.replace(/:/g, "")}`,
+      invoker,
+      setInvoker,
+      tooltip,
+      setTooltip,
+      arrowElement,
+      setArrowElement,
+      openTooltip,
+      closeTooltip,
+      placement,
+      openState,
+      setOpenState,
+      disableFlipFallback,
+      controlled: isControlled,
+      arrowRef,
+      resetKey: resetKey.current,
+      rootNode,
+      setRootNode
+    };
+  }, [
+    updatePosition,
+    id,
+    uid,
+    invoker,
+    tooltip,
+    arrowElement,
+    openTooltip,
+    closeTooltip,
+    placement,
+    openState,
+    disableFlipFallback,
+    isControlled,
+    arrowRef,
+    resetKey,
+    rootNode,
+    setRootNode
+  ]);
+  if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacy, { ...props });
+  return /* @__PURE__ */ jsx(TooltipContext.Provider, { value, children });
+};
+const Tooltip = Object.assign(TooltipElement, {
+  Trigger: TooltipTrigger,
+  Content: TooltipContent,
+  Context: TooltipContext
+});
+
+const Label = forwardRef((props, ref) => {
+  const { children, className, moreInfo, required, openMoreInfo, ...rest } = props;
+  const LabelClassNames = cx([styles$3["label"]], className);
+  return /* @__PURE__ */ jsxs("label", { className: LabelClassNames, "data-anv": "label", ref, ...rest, children: [
+    /* @__PURE__ */ jsxs("div", { className: styles$3["top-container"], "aria-atomic": "true", children: [
+      /* @__PURE__ */ jsxs("span", { className: styles$3["label-text"], children: [
+        children,
+        required ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("span", { "aria-hidden": true, className: styles$3["required"], children: "*" }),
+          /* @__PURE__ */ jsx(SrOnly, { children: "Required" })
+        ] }) : null
+      ] }),
+      moreInfo ? /* @__PURE__ */ jsxs(
+        Tooltip,
+        {
+          open: openMoreInfo ? openMoreInfo : void 0,
+          placement: "top",
+          fallbackPlacements: ["right", "bottom", "left"],
+          children: [
+            /* @__PURE__ */ jsx(Tooltip.Trigger, { className: styles$3["info-trigger"], children: /* @__PURE__ */ jsx(Icon, { svg: SvgInfo }) }),
+            /* @__PURE__ */ jsx(Tooltip.Content, { className: styles$3["info-content"], children: moreInfo })
+          ]
+        }
+      ) : null
+    ] }),
+    moreInfo ? /* @__PURE__ */ jsx(SrOnly, { children: moreInfo }) : null
+  ] });
+});
+Label.displayName = "Label";
+
+const bar = "_bar_1uffu_24";
+const indeterminate = "_indeterminate_1uffu_1";
+const success = "_success_1uffu_67";
+const error = "_error_1uffu_53";
+const styles = {
+	"progress-bar": "_progress-bar_1uffu_3",
+	"bar-container": "_bar-container_1uffu_24",
+	bar: bar,
+	"check-icon": "_check-icon_1uffu_50",
+	"error-icon": "_error-icon_1uffu_53",
+	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 { DialogHeader as D, Label as L, ProgressBar as P, TooltipTrigger as T, DialogFooter as a, DialogContent as b, DialogCancelButton as c, Dialog as d, DrawerCancelButton as e, DrawerFooter as f, DrawerHeader as g, DrawerContent as h, Drawer as i, TooltipContent as j, Tooltip as k, Toaster as l, DialogContext as m, DrawerContext as n, supportsPopover as s, toast as t, useKeyboardFocusables as u };
+//# sourceMappingURL=ProgressBar-C5jHU322-BUKq_wDl.js.map