@fluidattacks/design 8.1.0 → 8.2.0

package/dist/node_modules/react-joyride/dist/index.js

@@ -0,0 +1,2044 @@
+import E, { useMemo as J, useCallback as Q, useRef as N, useState as nt, useEffect as F, isValidElement as dt, cloneElement as ht } from "react";
+import { useMemoDeepCompare as $t, usePrevious as xt, useMount as Ut, useUpdateEffect as Mt, useWindowSize as jt } from "../../@gilbarbara/hooks/dist/index.js";
+import { s as Ht } from "../../../_virtual/index.js";
+import z from "../../is-lite/dist/index.js";
+import ut from "../../../_virtual/index2.js";
+import Yt from "../../../_virtual/index3.js";
+import It from "../../@gilbarbara/deep-equal/dist/index.js";
+import zt from "../../../_virtual/index4.js";
+import Nt from "../../../_virtual/scrollparent.js";
+import { createPortal as Wt } from "react-dom";
+import { offset as yt, shift as Kt, arrow as Gt, useFloating as Et, autoPlacement as Vt, flip as Jt } from "../../@floating-ui/react-dom/dist/floating-ui.react-dom.js";
+import { autoUpdate as Tt } from "../../@floating-ui/dom/dist/floating-ui.dom.js";
+const qt = {
+  arrowBase: 32,
+  arrowColor: "#ffffff",
+  arrowSize: 16,
+  arrowSpacing: 12,
+  backgroundColor: "#ffffff",
+  beaconSize: 36,
+  beaconTrigger: "click",
+  beforeTimeout: 5e3,
+  blockTargetInteraction: !1,
+  buttons: [
+    "back",
+    "close",
+    "primary"
+  ],
+  closeButtonAction: "close",
+  disableFocusTrap: !1,
+  dismissKeyAction: "close",
+  hideOverlay: !1,
+  loaderDelay: 300,
+  offset: 10,
+  overlayClickAction: "close",
+  overlayColor: "#00000080",
+  primaryColor: "#000000",
+  scrollDuration: 300,
+  scrollOffset: 20,
+  showProgress: !1,
+  skipBeacon: !1,
+  skipScroll: !1,
+  spotlightPadding: 10,
+  spotlightRadius: 4,
+  targetWaitTimeout: 1e3,
+  textColor: "#000000",
+  width: 380,
+  zIndex: 100
+}, Xt = { beaconOptions: { offset: -18 } }, At = {
+  back: "Back",
+  close: "Close",
+  last: "Last",
+  next: "Next",
+  nextWithProgress: "Next ({current} of {total})",
+  open: "Open the dialog",
+  skip: "Skip"
+}, Zt = {
+  isFixed: !1,
+  locale: At,
+  placement: "bottom"
+}, Qt = {
+  continuous: !1,
+  debug: !1,
+  run: !1,
+  scrollToFirstStep: !1,
+  steps: []
+}, R = {
+  INIT: "init",
+  START: "start",
+  STOP: "stop",
+  RESET: "reset",
+  PREV: "prev",
+  NEXT: "next",
+  GO: "go",
+  CLOSE: "close",
+  SKIP: "skip",
+  REPLAY: "replay",
+  UPDATE: "update",
+  COMPLETE: "complete"
+}, H = {
+  TOUR_START: "tour:start",
+  STEP_BEFORE_HOOK: "step:before_hook",
+  STEP_BEFORE: "step:before",
+  SCROLL_START: "scroll:start",
+  SCROLL_END: "scroll:end",
+  BEACON: "beacon",
+  TOOLTIP: "tooltip",
+  STEP_AFTER: "step:after",
+  STEP_AFTER_HOOK: "step:after_hook",
+  TOUR_END: "tour:end",
+  TOUR_STATUS: "tour:status",
+  TARGET_NOT_FOUND: "error:target_not_found",
+  ERROR: "error"
+}, d = {
+  INIT: "init",
+  READY: "ready",
+  BEACON_BEFORE: "beacon_before",
+  BEACON: "beacon",
+  TOOLTIP_BEFORE: "tooltip_before",
+  TOOLTIP: "tooltip",
+  COMPLETE: "complete"
+}, K = {
+  BUTTON_BACK: "button_back",
+  BUTTON_CLOSE: "button_close",
+  BUTTON_PRIMARY: "button_primary",
+  BUTTON_SKIP: "button_skip",
+  KEYBOARD: "keyboard",
+  OVERLAY: "overlay"
+}, w = {
+  IDLE: "idle",
+  READY: "ready",
+  WAITING: "waiting",
+  RUNNING: "running",
+  PAUSED: "paused",
+  SKIPPED: "skipped",
+  FINISHED: "finished"
+}, te = "react-joyride-portal";
+function ee(t) {
+  const e = {};
+  for (const n in t) t[n] !== void 0 && (e[n] = t[n]);
+  return e;
+}
+function et(...t) {
+  return Yt({
+    all: !0,
+    isMergeableObject: (e) => !(!z.plainObject(e) || dt(e))
+  })(...t);
+}
+function Lt(t) {
+  return Object.prototype.toString.call(t).slice(8, -1).toLowerCase();
+}
+function q(t, e = {}) {
+  const { defaultValue: n, step: o, steps: i } = e;
+  let r = ut(t);
+  if (r) (r.includes("{current}") || r.includes("{total}")) && o && i && (r = r.replace("{current}", o.toString()).replace("{total}", i.toString()));
+  else if (dt(t) && !Object.values(t.props).length && Lt(t.type) === "function") try {
+    r = q(t.type({}), e);
+  } catch {
+    r = ut(n);
+  }
+  else r = ut(n);
+  return r;
+}
+function Y(t, e, n, ...o) {
+  if (!t) return;
+  const i = /* @__PURE__ */ new Date(), r = `${String(i.getHours()).padStart(2, "0")}:${String(i.getMinutes()).padStart(2, "0")}:${String(i.getSeconds()).padStart(2, "0")}.${String(i.getMilliseconds()).padStart(3, "0")}`;
+  console.log(`${e} %c${n}%c ${r}`, "font-weight: bold", "color: gray; font-weight: normal", ...o);
+}
+function ne(t, e) {
+  const n = ee(e);
+  return {
+    ...t,
+    ...n
+  };
+}
+function st() {
+}
+function oe(t) {
+  return Object.keys(t);
+}
+function at(t, ...e) {
+  if (!z.plainObject(t)) throw new TypeError("Expected an object");
+  const n = {};
+  for (const o in t)
+    ({}).hasOwnProperty.call(t, o) && !e.includes(o) && (n[o] = t[o]);
+  return n;
+}
+function bt(t, ...e) {
+  if (!z.plainObject(t)) throw new TypeError("Expected an object");
+  if (!e.length) return t;
+  const n = {};
+  for (const o in t)
+    ({}).hasOwnProperty.call(t, o) && e.includes(o) && (n[o] = t[o]);
+  return n;
+}
+function ft(t, e, n) {
+  const o = (r) => r.replace("{current}", String(e)).replace("{total}", String(n));
+  if (Lt(t) === "string") return o(t);
+  if (!dt(t)) return t;
+  const { children: i } = t.props;
+  if (z.string(i) && i.includes("{current}")) return ht(t, { children: o(i) });
+  if (Array.isArray(i)) return ht(t, { children: i.map((r) => typeof r == "string" ? o(r) : ft(r, e, n)) });
+  if (z.function(t.type) && !Object.values(t.props).length) try {
+    return ft(t.type({}), e, n);
+  } catch {
+    return t;
+  }
+  return t;
+}
+function St(t) {
+  return oe(t).sort().reduce((e, n) => (e[n] = t[n], e), {});
+}
+function pt() {
+  return !!(typeof window < "u" && window.document?.createElement);
+}
+function Ot(t) {
+  let e = 0, n = 0, o = t;
+  for (; o; )
+    e += o.offsetTop, n += o.offsetLeft, o = o.offsetParent;
+  return {
+    left: n,
+    top: e
+  };
+}
+function gt(t) {
+  return t ? t.getBoundingClientRect() : null;
+}
+function re(t = !1) {
+  const { body: e, documentElement: n } = document;
+  if (!e || !n) return 0;
+  if (t) {
+    const o = [
+      e.scrollHeight,
+      e.offsetHeight,
+      n.clientHeight,
+      n.scrollHeight,
+      n.offsetHeight
+    ].sort((r, c) => r - c), i = Math.floor(o.length / 2);
+    return o.length % 2 === 0 ? (o[i - 1] + o[i]) / 2 : o[i];
+  }
+  return Math.max(e.scrollHeight, e.offsetHeight, n.clientHeight, n.scrollHeight, n.offsetHeight);
+}
+function V(t) {
+  if (!t) return null;
+  if (typeof t == "function") try {
+    return t();
+  } catch (e) {
+    return process.env.NODE_ENV !== "production" && console.error(e), null;
+  }
+  if (typeof t == "object" && "current" in t) return t.current;
+  if (typeof t == "string") try {
+    return document.querySelector(t);
+  } catch (e) {
+    return process.env.NODE_ENV !== "production" && console.error(e), null;
+  }
+  return t;
+}
+function ie(t, e, n) {
+  const o = gt(t), i = ot(t), r = i ? !i.isSameNode(W()) : !1, c = n ?? rt(t);
+  let u = 0, s = o?.top ?? 0;
+  return r && c ? s = o?.top ?? 0 : i instanceof HTMLElement && (u = i.scrollTop, !r && !c && (s += u), i.isSameNode(W()) || (s += W().scrollTop)), Math.floor(s - e);
+}
+function ot(t, e) {
+  if (!t) return W();
+  const n = Nt(t);
+  if (n) {
+    if (n.isSameNode(W()))
+      return e ? document : W();
+    if (!(n.scrollHeight > n.offsetHeight)) return W();
+  }
+  return n;
+}
+function se(t) {
+  const e = t.getBoundingClientRect(), n = W(), o = e.top + e.height / 2, i = window.innerHeight / 2;
+  return Math.max(0, n.scrollTop + o - i);
+}
+function ce(t, e) {
+  if (!t) return 0;
+  const n = Nt(t) ?? W(), o = parseFloat(getComputedStyle(t).scrollMarginTop) || 0, i = gt(n), r = n.scrollTop ?? 0, { offsetTop: c = 0, scrollTop: u = 0 } = n;
+  let s = t.getBoundingClientRect().top + u;
+  if (c && (vt(t) || le(t))) {
+    const g = t.getBoundingClientRect(), f = g.top - (i?.top ?? 0), l = f + g.height, h = n.clientHeight, T = h * 0.2;
+    f >= T && l <= h - T ? s = r : s = f + r;
+  }
+  const p = Math.floor(s - e - o);
+  return p < 0 ? 0 : p;
+}
+function le(t) {
+  return t.offsetParent !== document.body;
+}
+function vt(t) {
+  if (!t) return !1;
+  const e = ot(t);
+  return e ? !e.isSameNode(W()) : !1;
+}
+function rt(t, e = "fixed") {
+  if (!t || !(t instanceof Element)) return !1;
+  const { nodeName: n } = t;
+  return n === "BODY" || n === "HTML" ? !1 : getComputedStyle(t).position === e ? !0 : t.parentNode ? rt(t.parentNode, e) : !1;
+}
+function ct(t) {
+  if (!t) return !1;
+  let e = t;
+  for (; e && e !== document.body; ) {
+    if (e instanceof HTMLElement) {
+      const { display: n, visibility: o } = getComputedStyle(e);
+      if (n === "none" || o === "hidden") return !1;
+    }
+    e = e.parentElement ?? null;
+  }
+  return !0;
+}
+function Rt(t) {
+  const { isFirstStep: e, scrollToFirstStep: n, step: o, target: i, targetLifecycle: r } = t;
+  if (o.skipScroll || e && !n && r !== d.TOOLTIP || o.placement === "center") return !1;
+  const c = i?.isConnected ? ot(i) : W(), u = c ? !c.isSameNode(W()) : !1;
+  return (o.isFixed || rt(i)) && !u ? !1 : c.scrollHeight > c.clientHeight;
+}
+function W() {
+  return document.scrollingElement ?? document.documentElement;
+}
+function Ct(t, e) {
+  const { duration: n, element: o } = e;
+  let i = () => {
+  };
+  const r = new Promise((c) => {
+    const { scrollTop: u } = o, s = t > u ? t - u : u - t;
+    i = zt.top(o, t, { duration: s < 100 ? 50 : n }, () => {
+      c();
+    });
+  });
+  return {
+    cancel: i,
+    promise: r
+  };
+}
+function ae(t) {
+  const e = t.replace(/^#?([\da-f])([\da-f])([\da-f])$/i, (o, i, r, c) => i + i + r + r + c + c), n = /^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})/i.exec(e);
+  return n ? [
+    parseInt(n[1], 16),
+    parseInt(n[2], 16),
+    parseInt(n[3], 16)
+  ] : [];
+}
+const kt = {
+  backgroundColor: "transparent",
+  border: 0,
+  borderRadius: 0,
+  color: "#555555",
+  cursor: "pointer",
+  fontSize: 16,
+  lineHeight: 1,
+  padding: 0,
+  WebkitAppearance: "none"
+}, lt = {
+  ...kt,
+  borderRadius: 4,
+  padding: 8
+};
+function ue(t, e) {
+  const { styles: n } = t, o = et(n ?? {}, e.styles ?? {});
+  let { width: i } = e;
+  pt() && (i = typeof i == "number" && window.innerWidth < i ? window.innerWidth - 30 : i);
+  const r = {
+    bottom: 0,
+    left: 0,
+    overflow: "hidden",
+    position: "absolute",
+    right: 0,
+    top: 0,
+    zIndex: e.zIndex
+  };
+  return et({
+    arrow: {
+      alignItems: "center",
+      color: e.arrowColor,
+      display: "inline-flex",
+      justifyContent: "center",
+      position: "absolute"
+    },
+    beaconWrapper: {
+      ...kt,
+      display: "inline-flex",
+      borderRadius: "50%",
+      position: "relative"
+    },
+    beacon: {
+      height: e.beaconSize,
+      width: e.beaconSize
+    },
+    beaconInner: {
+      animation: "joyride-beacon-inner 1.2s infinite ease-in-out",
+      backgroundColor: e.primaryColor,
+      borderRadius: "50%",
+      display: "block",
+      height: "50%",
+      left: "50%",
+      opacity: 0.7,
+      position: "absolute",
+      top: "50%",
+      transform: "translate(-50%, -50%)",
+      width: "50%"
+    },
+    beaconOuter: {
+      animation: "joyride-beacon-outer 1.2s infinite ease-in-out",
+      backgroundColor: `rgba(${ae(e.primaryColor).join(",")}, 0.2)`,
+      border: `2px solid ${e.primaryColor}`,
+      borderRadius: "50%",
+      boxSizing: "border-box",
+      display: "block",
+      height: "100%",
+      left: 0,
+      opacity: 0.9,
+      position: "absolute",
+      top: 0,
+      transformOrigin: "center",
+      width: "100%"
+    },
+    buttonBack: {
+      ...lt,
+      color: e.primaryColor,
+      marginLeft: "auto",
+      marginRight: 5
+    },
+    buttonClose: {
+      ...lt,
+      color: e.textColor,
+      height: 12,
+      padding: 8,
+      position: "absolute",
+      right: 0,
+      top: 0,
+      width: 12
+    },
+    buttonPrimary: {
+      ...lt,
+      backgroundColor: e.primaryColor,
+      color: e.backgroundColor
+    },
+    buttonSkip: {
+      ...lt,
+      color: e.textColor,
+      fontSize: 14
+    },
+    floater: {
+      display: "inline-block",
+      filter: "drop-shadow(0 0 3px rgba(0, 0, 0, 0.3))",
+      maxWidth: "100%",
+      transition: "opacity 0.3s"
+    },
+    loader: {
+      alignItems: "center",
+      display: "flex",
+      height: 48,
+      inset: 0,
+      justifyContent: "center",
+      pointerEvents: "none",
+      position: "fixed",
+      width: 48,
+      zIndex: e.zIndex + 1
+    },
+    overlay: {
+      ...r,
+      backgroundColor: e.overlayColor
+    },
+    spotlight: {},
+    tooltip: {
+      backgroundColor: e.backgroundColor,
+      borderRadius: 5,
+      boxSizing: "border-box",
+      color: e.textColor,
+      fontSize: 16,
+      maxWidth: "100%",
+      padding: 12,
+      position: "relative",
+      width: i
+    },
+    tooltipContainer: {
+      lineHeight: 1.4,
+      textAlign: "center"
+    },
+    tooltipTitle: {
+      fontSize: 18,
+      margin: 0
+    },
+    tooltipContent: {
+      paddingBottom: 12,
+      paddingTop: 12
+    },
+    tooltipFooter: {
+      alignItems: "center",
+      display: "flex",
+      justifyContent: "flex-end"
+    },
+    tooltipFooterSpacer: { flex: 1 }
+  }, o);
+}
+const fe = [
+  "after",
+  "arrowBase",
+  "arrowColor",
+  "arrowSize",
+  "arrowSpacing",
+  "backgroundColor",
+  "beaconSize",
+  "beaconTrigger",
+  "before",
+  "beforeTimeout",
+  "buttons",
+  "closeButtonAction",
+  "skipBeacon",
+  "dismissKeyAction",
+  "disableFocusTrap",
+  "hideOverlay",
+  "skipScroll",
+  "blockTargetInteraction",
+  "loaderDelay",
+  "offset",
+  "overlayClickAction",
+  "overlayColor",
+  "primaryColor",
+  "scrollDuration",
+  "scrollOffset",
+  "showProgress",
+  "spotlightPadding",
+  "spotlightRadius",
+  "targetWaitTimeout",
+  "textColor",
+  "width",
+  "zIndex"
+];
+function mt(t, e) {
+  if (!e) return null;
+  const n = et(Zt, bt(t, "arrowComponent", "beaconComponent", "floatingOptions", "loaderComponent", "locale", "styles", "tooltipComponent"), e), o = et(qt, t.options ?? {}, bt(e, ...fe)), i = ue(t, {
+    ...n,
+    ...o
+  }), r = et(Xt, t.floatingOptions ?? {}, n.floatingOptions ?? {});
+  return {
+    ...n,
+    ...o,
+    locale: et(At, t.locale ?? {}, n.locale || {}),
+    floatingOptions: r,
+    spotlightPadding: de(o.spotlightPadding),
+    styles: i
+  };
+}
+function de(t) {
+  return typeof t == "number" ? {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  } : {
+    top: t?.top ?? 0,
+    right: t?.right ?? 0,
+    bottom: t?.bottom ?? 0,
+    left: t?.left ?? 0
+  };
+}
+function pe(t, e, n) {
+  const { action: o } = e, i = n && [R.PREV, R.NEXT].includes(o);
+  return t.skipBeacon || t.placement === "center" || i;
+}
+function Bt(t, e = !1) {
+  return z.plainObject(t) ? t.target ? !0 : (Y(e, "tour", "target is missing from the step"), !1) : (Y(e, "tour", "step must be an object"), !1);
+}
+function _t(t, e = !1) {
+  return z.array(t) ? t.every((n) => Bt(n, e)) : (Y(e, "tour", "steps must be an array"), !1);
+}
+var ge = class {
+  beaconPosition = null;
+  debug;
+  eventListeners = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  props;
+  snapshot;
+  state;
+  steps;
+  tooltipPosition = null;
+  constructor(t) {
+    const { initialStepIndex: e, stepIndex: n, steps: o = [] } = t ?? {}, i = z.number(n);
+    let r = 0;
+    this.debug = t?.debug ?? !1, i ? (r = n, z.number(e) && Y(this.debug, "tour", "initialStepIndex is ignored in controlled mode")) : z.number(e) && (e >= 0 && e < o.length ? r = e : o.length > 0 && Y(this.debug, "tour", "initialStepIndex is out of bounds")), this.props = t ?? { steps: [] }, this.steps = o, this.state = {
+      action: R.INIT,
+      controlled: i,
+      index: r,
+      lifecycle: d.INIT,
+      origin: null,
+      positioned: !1,
+      scrolling: !1,
+      size: o.length,
+      status: o.length ? w.READY : w.IDLE,
+      waiting: !1
+    }, this.snapshot = Object.freeze({ ...this.state });
+  }
+  applyTransitions(t) {
+    return t.status === w.WAITING && t.size > 0 ? {
+      ...t,
+      status: w.RUNNING
+    } : t;
+  }
+  getStep(t) {
+    return mt(this.props, this.steps[t ?? this.state.index]);
+  }
+  cleanupPositionData = () => {
+    this.beaconPosition = null, this.tooltipPosition = null;
+  };
+  getPositionData = (t) => t === "beacon" ? this.beaconPosition : this.tooltipPosition;
+  getServerSnapshot = () => this.snapshot;
+  getSnapshot = () => this.snapshot;
+  getEventState = () => at(this.snapshot, "positioned");
+  getState = () => at(this.snapshot, "positioned");
+  setPositionData = (t, e) => {
+    (t === "beacon" ? this.beaconPosition : this.tooltipPosition)?.placement !== e.placement && Y(this.debug, `step:${this.state.index}`, "positioned", `${t} ${e.placement}`), t === "beacon" ? this.beaconPosition = e : this.tooltipPosition = e, (this.state.lifecycle === d.BEACON_BEFORE || this.state.lifecycle === d.TOOLTIP_BEFORE) && !this.state.positioned && this.updateState({ positioned: !0 });
+    const n = this.getStep()?.floatingOptions?.onPosition;
+    n && n(e);
+  };
+  setSteps = (t) => {
+    this.steps = t, this.updateState({ size: t.length });
+  };
+  dispatch = (t, e) => {
+    const n = this.eventListeners.get(t.type);
+    if (n) for (const o of n) try {
+      o(t, e);
+    } catch {
+    }
+  };
+  on = (t, e) => {
+    let n = this.eventListeners.get(t);
+    return n || (n = /* @__PURE__ */ new Set(), this.eventListeners.set(t, n)), n.add(e), () => {
+      n.delete(e);
+    };
+  };
+  subscribe = (t) => (this.listeners.add(t), () => {
+    this.listeners.delete(t);
+  });
+  updateState = (t, e = !1) => {
+    const { controlled: n, index: o } = this.state, i = this.snapshot, r = n && !e && t.index !== void 0 ? o : t.index ?? o, c = {
+      action: t.action ?? this.state.action,
+      controlled: n,
+      index: r,
+      lifecycle: t.lifecycle ?? this.state.lifecycle,
+      origin: t.origin ?? null,
+      positioned: t.positioned ?? this.state.positioned,
+      scrolling: t.scrolling ?? this.state.scrolling,
+      size: t.size ?? this.state.size,
+      status: t.status ?? this.state.status,
+      waiting: t.waiting ?? this.state.waiting
+    }, u = this.applyTransitions(c);
+    if (this.state = u, !It(i, u)) {
+      this.snapshot = Object.freeze({ ...u });
+      for (const s of this.listeners) s(this.snapshot);
+    }
+  };
+};
+function me(t) {
+  return new ge(t);
+}
+function wt(t, e) {
+  return Math.min(Math.max(t, 0), e);
+}
+function he(t, e, n) {
+  const o = N(e), i = N(n);
+  return o.current = e, i.current = n, J(() => {
+    const r = () => t.current.getSnapshot();
+    return {
+      close: (a = null) => {
+        const { index: m, status: y } = r();
+        y === w.RUNNING && t.current.updateState({
+          action: R.CLOSE,
+          index: m + 1,
+          origin: a,
+          lifecycle: d.COMPLETE,
+          positioned: !1,
+          scrolling: !1,
+          waiting: !1
+        });
+      },
+      go: (a) => {
+        const { controlled: m, size: y, status: x } = r();
+        if (m) {
+          Y(o.current, "tour", "go() is not supported in controlled mode");
+          return;
+        }
+        x === w.RUNNING && t.current.updateState({
+          action: R.GO,
+          index: a,
+          lifecycle: d.COMPLETE,
+          positioned: !1,
+          scrolling: !1,
+          status: a < y ? x : w.FINISHED,
+          waiting: !1
+        });
+      },
+      info: () => at(t.current.getSnapshot(), "positioned"),
+      next: (a) => {
+        const { index: m, size: y, status: x } = r();
+        x === w.RUNNING && t.current.updateState({
+          action: R.NEXT,
+          index: wt(m + 1, y),
+          lifecycle: d.COMPLETE,
+          origin: a,
+          positioned: !1,
+          scrolling: !1,
+          waiting: !1
+        });
+      },
+      open: () => {
+        const { status: a } = r();
+        a === w.RUNNING && t.current.updateState({
+          action: R.UPDATE,
+          lifecycle: d.TOOLTIP_BEFORE,
+          positioned: !1,
+          scrolling: !1,
+          waiting: !1
+        });
+      },
+      prev: (a) => {
+        const { index: m, size: y, status: x } = r();
+        x === w.RUNNING && t.current.updateState({
+          action: R.PREV,
+          index: wt(m - 1, y),
+          lifecycle: d.COMPLETE,
+          origin: a,
+          positioned: !1,
+          scrolling: !1,
+          waiting: !1
+        });
+      },
+      replay: (a) => {
+        const { lifecycle: m, status: y } = r();
+        y !== w.RUNNING || m !== d.TOOLTIP || t.current.updateState({
+          action: R.REPLAY,
+          lifecycle: d.COMPLETE,
+          origin: a,
+          positioned: !1,
+          scrolling: !1,
+          waiting: !1
+        });
+      },
+      reset: (a = !1) => {
+        const { controlled: m } = r();
+        if (m) {
+          Y(o.current, "tour", "reset() is not supported in controlled mode");
+          return;
+        }
+        i.current(), t.current.updateState({
+          action: R.RESET,
+          index: 0,
+          lifecycle: d.INIT,
+          positioned: !1,
+          scrolling: !1,
+          status: a ? w.RUNNING : w.READY,
+          waiting: !1
+        });
+      },
+      skip: (a) => {
+        const { status: m } = r();
+        m === w.RUNNING && t.current.updateState({
+          action: R.SKIP,
+          lifecycle: d.COMPLETE,
+          origin: a,
+          positioned: !1,
+          scrolling: !1,
+          status: w.SKIPPED,
+          waiting: !1
+        });
+      },
+      start: (a) => {
+        const { index: m, size: y } = r();
+        i.current(), t.current.updateState({
+          action: R.START,
+          index: z.number(a) ? a : m,
+          lifecycle: d.INIT,
+          positioned: !1,
+          scrolling: !1,
+          status: y ? w.RUNNING : w.WAITING,
+          waiting: !1
+        }, !0);
+      },
+      stop: (a = !1) => {
+        const { index: m, status: y } = r();
+        [w.FINISHED, w.SKIPPED].includes(y) || t.current.updateState({
+          action: R.STOP,
+          index: m + (a ? 1 : 0),
+          lifecycle: d.COMPLETE,
+          positioned: !1,
+          scrolling: !1,
+          status: w.PAUSED,
+          waiting: !1
+        });
+      }
+    };
+  }, [t]);
+}
+const ye = /* @__PURE__ */ new Set(["origin", "positioned"]);
+function Ee(t, e) {
+  const n = N(null);
+  F(() => {
+    if (!e) return;
+    const o = t.current.getSnapshot();
+    return Y(!0, "tour", "init", o), n.current = o, t.current.subscribe((i) => {
+      const r = n.current;
+      if (n.current = i, !r) return;
+      const c = {};
+      let u = !1;
+      for (const s of Object.keys(i)) i[s] !== r[s] && !ye.has(s) && (c[s] = {
+        from: r[s],
+        to: i[s]
+      }, (s === "status" || s === "size") && (u = !0));
+      Object.keys(c).length && (!u && i.index >= i.size || Y(!0, u ? "tour" : `step:${i.index}`, "state", c));
+    });
+  }, [e, t]);
+}
+function Te(t, e, n) {
+  const o = N(t), i = N(e);
+  return o.current = t, i.current = e, Q((r, c, u) => {
+    const s = {
+      ...n.current.getEventState(),
+      error: null,
+      scroll: null,
+      step: c,
+      type: r,
+      ...u
+    };
+    o.current?.(s, i.current), n.current.dispatch(s, i.current);
+  }, [n]);
+}
+function Z(t, e) {
+  return {
+    hasChanged(n) {
+      return t[n] !== e[n];
+    },
+    hasChangedTo(n, o) {
+      const i = t[n], r = e[n];
+      return Array.isArray(o) ? o.includes(i) && !o.includes(r) : i === o && r !== o;
+    },
+    previous: e
+  };
+}
+function be(t) {
+  const { addFailure: e, controls: n, emitEvent: o, previousState: i, props: r, state: c, step: u, store: s } = t, { action: p, index: g, lifecycle: f, positioned: l, scrolling: h, size: T, status: P } = c, v = xt(u) ?? null, a = N(null), m = N(r), y = N(c), x = N(i), _ = N(u), $ = N(v), U = N(n), D = N(null), G = N(null), M = N(null);
+  m.current = r, y.current = c, x.current = i, _.current = u, $.current = v, U.current = n;
+  const O = () => {
+    D.current && (clearInterval(D.current), D.current = null), G.current = null, M.current && (M.current.cancel(), M.current = null);
+  };
+  F(() => {
+    if (!x.current) return;
+    const { hasChangedTo: S } = Z(y.current, x.current), b = S("action", [
+      R.NEXT,
+      R.PREV,
+      R.SKIP,
+      R.CLOSE,
+      R.REPLAY
+    ]), C = p === R.START && (a.current === R.CLOSE || a.current === R.REPLAY);
+    (b || C) && (a.current = p);
+  }, [p]), F(() => {
+    if (!x.current) return () => {
+      O();
+    };
+    const { hasChanged: S } = Z(y.current, x.current), b = _.current;
+    if (S("index") && O(), P !== w.RUNNING || !b || f !== d.INIT) return () => {
+      O();
+    };
+    const { hasChangedTo: C } = Z(y.current, x.current);
+    C("status", w.RUNNING) && [
+      w.IDLE,
+      w.READY,
+      w.PAUSED
+    ].includes(x.current.status) && o(H.TOUR_START, b), s.current.cleanupPositionData();
+    const { debug: A } = m.current;
+    if (b.before && !M.current) {
+      Y(A, `step:${g}`, "before()", b), M.current = { cancel: () => {
+      } }, s.current.updateState({ waiting: !0 }), o(H.STEP_BEFORE_HOOK, b, { action: a.current ?? y.current.action });
+      const B = () => {
+        M.current = null, s.current.updateState({
+          action: a.current ?? y.current.action,
+          waiting: !1,
+          lifecycle: d.READY
+        });
+      }, I = new AbortController(), k = b.beforeTimeout;
+      M.current = { cancel: () => I.abort() };
+      const L = k ? setTimeout(() => {
+        I.signal.aborted || (Y(A, `step:${g}`, "before()", "timed out", `${k}ms`), I.abort(), e(b, "before_hook"), o(H.ERROR, b, { error: /* @__PURE__ */ new Error("Step before hook timed out") }), B());
+      }, k) : null;
+      b.before({
+        ...s.current.getState(),
+        action: a.current ?? s.current.getState().action,
+        step: b
+      }).then(() => {
+        I.signal.aborted || (L && clearTimeout(L), B());
+      }).catch((j) => {
+        I.signal.aborted || (L && clearTimeout(L), e(b, "before_hook"), o(H.ERROR, b, { error: j instanceof Error ? j : new Error(String(j)) }), B());
+      });
+    } else if (!M.current) {
+      D.current && G.current !== b.target && O();
+      const B = V(b.target);
+      if (B && ct(B))
+        O(), s.current.updateState({
+          action: a.current ?? R.UPDATE,
+          lifecycle: d.READY,
+          waiting: !1
+        });
+      else if (b.targetWaitTimeout === 0) s.current.updateState({
+        action: a.current ?? R.UPDATE,
+        lifecycle: d.READY,
+        waiting: !1
+      });
+      else if (!D.current) {
+        const { targetWaitTimeout: I } = b, k = Date.now();
+        G.current = b.target, Y(A, `step:${g}`, "polling", "started", `${I}ms`), s.current.updateState({ waiting: !0 }), D.current = setInterval(() => {
+          const L = V(b.target), j = Date.now() - k, tt = j >= I;
+          (L && ct(L) || tt) && (Y(A, `step:${g}`, "polling", L && ct(L) ? "found" : "timed out", `${j}ms`), O(), s.current.updateState({
+            action: a.current ?? R.UPDATE,
+            lifecycle: d.READY,
+            waiting: !1
+          }));
+        }, 100);
+      }
+    }
+    return () => {
+      O();
+    };
+  }, [
+    e,
+    o,
+    g,
+    f,
+    P,
+    s
+  ]), F(() => {
+    if (!x.current) return;
+    const { hasChanged: S, hasChangedTo: b, previous: C } = Z(y.current, x.current), A = _.current;
+    if (!A) return;
+    const B = V(A.target), I = !!B;
+    if (I && ct(B)) {
+      if (b("lifecycle", d.READY) && C.lifecycle === d.INIT && o(H.STEP_BEFORE, A, { action: a.current ?? y.current.action }), b("lifecycle", d.READY)) {
+        const k = y.current, L = pe(A, k, m.current.continuous) ? d.TOOLTIP : d.BEACON, j = V(A.scrollTarget ?? A.spotlightTarget ?? A.target), tt = Rt({
+          isFirstStep: k.index === 0,
+          scrollToFirstStep: m.current.scrollToFirstStep,
+          step: A,
+          target: j,
+          targetLifecycle: L
+        }), Ft = L === d.TOOLTIP ? d.TOOLTIP_BEFORE : d.BEACON_BEFORE;
+        Y(m.current.debug, `step:${g}`, "scroll", tt ? "needed" : "skipped"), s.current.updateState({
+          action: R.UPDATE,
+          lifecycle: Ft,
+          scrolling: tt
+        });
+      }
+    } else if (y.current.status === w.RUNNING && f !== d.INIT && f !== d.COMPLETE && S("lifecycle")) {
+      Y(m.current.debug, `step:${g}`, I ? "Target not visible" : "Target not mounted", A), e(A, "target_not_found"), o(H.TARGET_NOT_FOUND, A);
+      const k = y.current;
+      k.controlled || s.current.updateState({
+        action: R.UPDATE,
+        index: k.index + (k.action === R.PREV ? -1 : 1),
+        lifecycle: d.INIT
+      });
+    }
+  }, [
+    e,
+    o,
+    g,
+    f,
+    s
+  ]), F(() => {
+    if (!x.current) return;
+    const { hasChangedTo: S, previous: b } = Z(y.current, x.current), C = _.current, A = $.current;
+    if (C && S("lifecycle", d.TOOLTIP_BEFORE) && b.lifecycle === d.BEACON) {
+      const k = V(C.scrollTarget ?? C.spotlightTarget ?? C.target);
+      if (Rt({
+        isFirstStep: y.current.index === 0,
+        scrollToFirstStep: m.current.scrollToFirstStep,
+        step: C,
+        target: k,
+        targetLifecycle: d.TOOLTIP
+      })) {
+        s.current.updateState({
+          scrolling: !0,
+          positioned: !1
+        });
+        return;
+      }
+    }
+    const B = f === d.BEACON_BEFORE || f === d.TOOLTIP_BEFORE;
+    if (C && B && !h) {
+      const k = f === d.TOOLTIP_BEFORE ? d.TOOLTIP : d.BEACON;
+      s.current.updateState({
+        action: R.UPDATE,
+        lifecycle: k
+      });
+    }
+    C && S("lifecycle", d.BEACON) && o(H.BEACON, C), C && S("lifecycle", d.TOOLTIP) && o(H.TOOLTIP, C);
+    const I = y.current;
+    if ((I.status === w.RUNNING || I.controlled && I.status === w.PAUSED && C) && A && S("lifecycle", d.COMPLETE) && b.lifecycle === d.TOOLTIP && (o(H.STEP_AFTER, A, {
+      action: a.current ?? R.UPDATE,
+      index: b.index ?? I.index,
+      lifecycle: I.lifecycle
+    }), A.after)) {
+      o(H.STEP_AFTER_HOOK, A, {
+        action: a.current ?? R.UPDATE,
+        index: b.index ?? I.index,
+        lifecycle: I.lifecycle
+      });
+      try {
+        A.after({
+          ...s.current.getState(),
+          action: a.current ?? R.UPDATE,
+          index: b.index ?? I.index,
+          lifecycle: I.lifecycle,
+          step: A
+        });
+      } catch {
+      }
+    }
+  }, [
+    o,
+    f,
+    l,
+    h,
+    s
+  ]), F(() => {
+    if (!x.current) return;
+    const { hasChangedTo: S, previous: b } = Z(y.current, x.current), C = _.current, A = $.current;
+    if (S("action", R.REPLAY) && S("lifecycle", d.COMPLETE)) {
+      s.current.updateState({ lifecycle: d.INIT });
+      return;
+    }
+    T && !C && f === d.INIT && s.current.updateState({
+      action: R.UPDATE,
+      lifecycle: d.COMPLETE,
+      status: w.FINISHED
+    }), !y.current.controlled && P === w.RUNNING && S("lifecycle", d.COMPLETE) && g < T && s.current.updateState({
+      action: R.UPDATE,
+      lifecycle: d.INIT
+    }), S("lifecycle", d.COMPLETE) && g >= T && s.current.updateState({
+      action: R.UPDATE,
+      lifecycle: d.COMPLETE,
+      status: w.FINISHED
+    });
+    const B = C ?? A ?? mt(m.current, m.current.steps[g - 1]);
+    if (B && S("status", [w.FINISHED, w.SKIPPED])) {
+      let I;
+      C ? I = g : A ? I = b.index ?? g : I = g - 1, o(H.TOUR_END, B, { index: I }), y.current.controlled || U.current.reset(), a.current = null;
+    }
+    C && S("action", R.STOP) && (a.current = null, o(H.TOUR_STATUS, C)), C && S("action", R.RESET) && (o(H.TOUR_STATUS, C), a.current = null);
+  }, [
+    p,
+    o,
+    g,
+    f,
+    T,
+    P,
+    s
+  ]);
+}
+function Se({ controls: t, emitEvent: e, props: n, state: o, store: i }) {
+  const { debug: r, initialStepIndex: c, run: u, stepIndex: s, steps: p } = n, g = N(void 0), f = N(o), l = N(t);
+  f.current = o, l.current = t, F(() => {
+    const h = g.current;
+    if (g.current = n, !h || n === h) return;
+    const { hasChanged: T } = Z(n, h);
+    if (It(h.steps, p) || (_t(p, r) ? i.current.setSteps(p) : (Y(r, "tour", "Steps are not valid", p), e(H.ERROR, p[0] ?? {
+      target: "",
+      content: ""
+    }, { error: /* @__PURE__ */ new Error("Steps are not valid") }))), T("run")) u ? i.current.getState().size && l.current.start(s ?? c) : l.current.stop();
+    else if (z.number(s) && T("stepIndex")) {
+      const P = z.number(h.stepIndex) && h.stepIndex < s ? R.NEXT : R.PREV;
+      [w.FINISHED, w.SKIPPED].includes(f.current.status) || i.current.updateState({
+        action: P,
+        index: s,
+        lifecycle: d.INIT,
+        positioned: !1
+      }, !0);
+    }
+  }, [
+    r,
+    e,
+    c,
+    n,
+    u,
+    s,
+    p,
+    i
+  ]);
+}
+function Oe(t, e) {
+  const { beaconPosition: n, lifecycle: o, scrollOffset: i, step: r } = e;
+  if (r.scrollTarget || r.spotlightTarget) return Math.max(0, t);
+  let c = t - r.spotlightPadding.top;
+  if (o === d.BEACON_BEFORE && n?.placement) {
+    const u = Re(n);
+    ["bottom"].includes(n.placement) || (c += Math.floor(u - i));
+  } else if (o === d.TOOLTIP_BEFORE) {
+    const { placement: u } = r;
+    if (u === "top") {
+      const s = document.querySelector(".react-joyride__floater")?.getBoundingClientRect().height ?? 0, p = r.floatingOptions?.hideArrow ? 0 : r.arrowSize, g = r.offset + r.spotlightPadding.top + p;
+      c -= s + g;
+    } else if (u === "left" || u === "right") {
+      const s = document.querySelector(".react-joyride__floater")?.getBoundingClientRect().height ?? 0, p = V(r.target)?.getBoundingClientRect().height ?? 0, g = i + r.spotlightPadding.top + p / 2 - s / 2;
+      g < i && (c -= i - g);
+    }
+  }
+  return Math.max(0, c);
+}
+function Re(t) {
+  const e = t.middlewareData?.offset;
+  return e ? ["left", "right"].some((n) => t.placement.startsWith(n)) ? e.x : e.y : 0;
+}
+function Ce({ emitEvent: t, previousState: e, props: n, state: o, step: i, store: r }) {
+  const { index: c, lifecycle: u, positioned: s, scrolling: p, status: g } = o, f = N(null), l = N(o), h = N(e), T = N(n), P = N(i);
+  l.current = o, h.current = e, T.current = n, P.current = i, F(() => () => {
+    f.current?.();
+  }, []), F(() => {
+    if (!h.current || !P.current) return;
+    const { hasChangedTo: v } = Z(l.current, h.current), a = P.current, { debug: m } = T.current, { scrollDuration: y } = a, x = u === d.BEACON_BEFORE || u === d.TOOLTIP_BEFORE;
+    if (g === w.RUNNING && x && p && v("positioned", !0)) {
+      const _ = V(a.scrollTarget ?? a.spotlightTarget ?? a.target), $ = r.current.getPositionData("beacon"), U = ot(_), D = U ? !U.isSameNode(W()) : !1;
+      f.current?.(), (async () => {
+        if (D && !rt(U)) {
+          const B = W(), I = se(U), k = {
+            initial: B.scrollTop,
+            target: I,
+            element: B,
+            duration: y
+          };
+          t(H.SCROLL_START, a, { scroll: k });
+          const { cancel: L, promise: j } = Ct(I, {
+            element: B,
+            duration: y
+          });
+          f.current = L, await j, t(H.SCROLL_END, a, { scroll: k });
+        }
+        const M = Math.floor(ce(_, a.scrollOffset)) || 0, O = D ? M : Oe(M, {
+          beaconPosition: $,
+          lifecycle: u,
+          scrollOffset: a.scrollOffset,
+          step: a
+        });
+        Y(m, `step:${c}`, "scroll", D ? "custom" : "document", `${M} → ${O}`);
+        const S = U, b = {
+          initial: S.scrollTop,
+          target: O,
+          element: S,
+          duration: y
+        };
+        t(H.SCROLL_START, a, { scroll: b });
+        const { cancel: C, promise: A } = Ct(O, {
+          element: S,
+          duration: y
+        });
+        f.current = C, await A, t(H.SCROLL_END, a, { scroll: b }), r.current.updateState({ scrolling: !1 });
+      })().catch(() => {
+        r.current.updateState({ scrolling: !1 });
+      });
+    }
+  }, [
+    t,
+    c,
+    u,
+    s,
+    p,
+    g,
+    r
+  ]);
+}
+function we(t) {
+  const e = $t(() => ne(Qt, t), [t]), { debug: n, initialStepIndex: o, onEvent: i, run: r, stepIndex: c, steps: u } = e, s = N(me(e)), p = Ht.useSyncExternalStore(s.current.subscribe, s.current.getSnapshot, s.current.getServerSnapshot), [g, f] = nt([]), l = Q((_, $) => {
+    f((U) => [...U, {
+      reason: $,
+      step: _
+    }]);
+  }, []), h = Q(() => {
+    f([]);
+  }, []);
+  Ee(s, n);
+  const T = he(s, n, h), P = Te(i, T, s), { index: v, size: a, status: m } = p, y = xt(p), x = J(() => mt(e, u[v]), [
+    v,
+    e,
+    u
+  ]);
+  return Ut(() => {
+    r && a && _t(u, n) && T.start(c ?? o);
+  }), Mt(() => {
+    r && a && m === w.IDLE && s.current.updateState({ status: w.READY });
+  }, [
+    r,
+    a,
+    m
+  ]), Se({
+    controls: T,
+    emitEvent: P,
+    props: e,
+    state: p,
+    store: s
+  }), be({
+    addFailure: l,
+    controls: T,
+    emitEvent: P,
+    previousState: y,
+    props: e,
+    state: p,
+    step: x,
+    store: s
+  }), Ce({
+    emitEvent: P,
+    previousState: y,
+    props: e,
+    state: p,
+    step: x,
+    store: s
+  }), {
+    controls: T,
+    failures: g,
+    mergedProps: e,
+    state: p,
+    step: x,
+    store: s
+  };
+}
+function Pe(t) {
+  const [e, n] = nt(null);
+  return F(() => {
+    let o = null, i = !1;
+    if (t) if (z.domElement(t))
+      o = t, i = !0;
+    else {
+      const r = document.querySelector(t);
+      r && (o = r);
+    }
+    else {
+      const r = document.createElement("div");
+      r.id = te, document.body.appendChild(r), o = r;
+    }
+    return n(o), () => {
+      !o || i || o.parentNode === document.body && document.body.removeChild(o);
+    };
+  }, [t]), e;
+}
+const xe = {
+  animation: "joyride-loader-spin 1s linear infinite",
+  border: "5px solid rgba(0, 0, 0, 0.1)",
+  borderRadius: "50%",
+  borderTopColor: "#555"
+};
+function Ie({ nonce: t, step: e }) {
+  const { loaderComponent: n } = e, o = !!n;
+  if (F(() => {
+    if (o || document.getElementById("joyride-loader-animation")) return st;
+    const s = document.createElement("style");
+    return s.id = "joyride-loader-animation", t && s.setAttribute("nonce", t), s.appendChild(document.createTextNode(`
+        @keyframes joyride-loader-spin {
+          to { transform: rotate(360deg); }
+        }
+      `)), document.head.appendChild(s), () => {
+      const p = document.getElementById("joyride-loader-animation");
+      p?.parentNode && p.parentNode.removeChild(p);
+    };
+  }, [o, t]), n === null) return null;
+  const { height: i, width: r, ...c } = e.styles.loader;
+  let u;
+  if (n) {
+    const s = n;
+    u = /* @__PURE__ */ E.createElement(s, { step: e });
+  } else u = /* @__PURE__ */ E.createElement("div", { style: {
+    ...xe,
+    height: i,
+    width: r,
+    borderTopColor: e.primaryColor
+  } });
+  return /* @__PURE__ */ E.createElement("div", {
+    className: "react-joyride__loader",
+    "data-testid": "loader",
+    style: c
+  }, u);
+}
+const Ne = {
+  height: 0,
+  isFixed: !1,
+  left: 0,
+  top: 0,
+  width: 0
+};
+function it(t, e) {
+  const n = V(t);
+  if (!n) return Ne;
+  const o = gt(n), i = rt(n), r = ie(n, e.top, i);
+  return {
+    height: Math.round((o?.height ?? 0) + e.top + e.bottom),
+    isFixed: i,
+    left: Math.round((o?.left ?? 0) - e.left),
+    top: r,
+    width: Math.round((o?.width ?? 0) + e.left + e.right)
+  };
+}
+function Ae(t, e, n) {
+  const [o, i] = nt(() => it(t, e)), r = N(void 0), c = N(null), u = N(n), s = N(null), p = Q(() => {
+    clearTimeout(r.current), r.current = window.setTimeout(() => {
+      i((f) => {
+        const l = it(t, e);
+        return f.top === l.top && f.left === l.left && f.width === l.width && f.height === l.height && f.isFixed === l.isFixed ? f : l;
+      });
+    }, 100);
+  }, [t, e]);
+  F(() => {
+    let f = null;
+    const l = (T) => {
+      c.current = ot(T, !0), c.current && c.current.addEventListener("scroll", p, { passive: !0 }), window.addEventListener("scroll", p, { passive: !0 }), window.addEventListener("resize", p), typeof ResizeObserver < "u" && (s.current = new ResizeObserver(p), s.current.observe(T)), i(it(t, e));
+    }, h = V(t);
+    return h ? l(h) : (f = new MutationObserver(() => {
+      const T = V(t);
+      T && (f?.disconnect(), f = null, l(T));
+    }), f.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })), () => {
+      f?.disconnect(), c.current && c.current.removeEventListener("scroll", p), window.removeEventListener("scroll", p), window.removeEventListener("resize", p), s.current?.disconnect(), clearTimeout(r.current);
+    };
+  }, [
+    t,
+    e,
+    p
+  ]), F(() => {
+    u.current && !n && i(it(t, e)), u.current = n;
+  }, [
+    n,
+    t,
+    e
+  ]);
+  let g = o;
+  return u.current && !n && (g = it(t, e)), g;
+}
+function Le(t, e, n) {
+  let o = `M0 0H${t}V${e}H0Z`;
+  return n && (o += ` ${n}`), o;
+}
+function Pt(t, e, n, o, i) {
+  if (n <= 0 || o <= 0) return "";
+  const r = Math.max(0, Math.min(i, n / 2, o / 2));
+  let c = `M${t + r} ${e}`;
+  return c += `H${t + n - r}`, c += `A${r} ${r} 0 0 1 ${t + n} ${e + r}`, c += `V${e + o - r}`, c += `A${r} ${r} 0 0 1 ${t + n - r} ${e + o}`, c += `H${t + r}`, c += `A${r} ${r} 0 0 1 ${t} ${e + o - r}`, c += `V${e + r}`, c += `A${r} ${r} 0 0 1 ${t + r} ${e}Z`, c;
+}
+const ve = [d.BEACON_BEFORE, d.BEACON];
+function ke(t) {
+  const { blockTargetInteraction: e, continuous: n, hideOverlay: o, lifecycle: i, onClickOverlay: r, overlayClickAction: c, placement: u, portalElement: s, scrolling: p, spotlightPadding: g, spotlightRadius: f, spotlightTarget: l, styles: h, target: T, waiting: P } = t, v = jt(), a = Ae(l ?? T, g, p || P), m = N(null), y = (i === d.TOOLTIP || i === d.TOOLTIP_BEFORE) && u !== "center", [x, _] = nt(!1), $ = s ? m.current?.offsetParent : null, U = $?.clientWidth ?? v.width, D = $?.clientHeight ?? re() ?? v.height, G = h.overlay?.backgroundColor ?? "rgba(0, 0, 0, 0.5)", M = J(() => {
+    const { backgroundColor: B, mixBlendMode: I, ...k } = h.overlay;
+    return {
+      height: D,
+      pointerEvents: "none",
+      ...k
+    };
+  }, [D, h.overlay]), O = y && !p && !P;
+  F(() => {
+    O ? requestAnimationFrame(() => _(!0)) : _(!1);
+  }, [O]);
+  const S = n && ve.includes(i), b = !n && i !== d.TOOLTIP;
+  if (o || !P && (S || b)) return null;
+  let C = "";
+  if (O) if (s && $) {
+    const B = V(l ?? T);
+    if (B) {
+      const I = Ot(B), k = Ot($);
+      C = Pt(I.left - k.left - g.left, I.top - k.top - g.top, B.offsetWidth + g.left + g.right, B.offsetHeight + g.top + g.bottom, f);
+    }
+  } else C = Pt(a.left, a.top, a.width, a.height, f);
+  const A = Le(U, D, C);
+  return /* @__PURE__ */ E.createElement("div", {
+    ref: m,
+    "aria-hidden": "true",
+    className: "react-joyride__overlay",
+    "data-testid": "overlay",
+    style: M
+  }, /* @__PURE__ */ E.createElement("svg", {
+    className: "react-joyride__spotlight",
+    "data-testid": "spotlight",
+    style: {
+      height: D,
+      left: 0,
+      position: a.isFixed ? "fixed" : "absolute",
+      top: 0,
+      width: U
+    }
+  }, /* @__PURE__ */ E.createElement("path", {
+    d: A,
+    fill: G,
+    fillRule: "evenodd",
+    onClick: r,
+    style: {
+      cursor: c ? "pointer" : "default",
+      pointerEvents: "auto"
+    }
+  }), C && /* @__PURE__ */ E.createElement("path", {
+    d: C,
+    fill: G,
+    style: {
+      opacity: x ? 0 : 1,
+      pointerEvents: e ? "auto" : "none",
+      transition: "opacity 0.2s"
+    }
+  }), C && Object.keys(h.spotlight).length > 0 && /* @__PURE__ */ E.createElement("path", {
+    d: C,
+    fill: "none",
+    style: { pointerEvents: "none" },
+    ...h.spotlight
+  })));
+}
+function Dt(t) {
+  const { children: e, element: n } = t;
+  return n ? Wt(e, n) : null;
+}
+const Be = 'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), area[href], [tabindex]:not([tabindex="-1"]), [contenteditable]';
+function _e(t, e) {
+  const n = N(null);
+  F(() => {
+    if (!t) return st;
+    n.current = document.activeElement;
+    const o = (r) => {
+      if (r.key !== "Tab") return;
+      const c = [...t.querySelectorAll(Be)], { shiftKey: u } = r;
+      if (!c.length) return;
+      r.preventDefault();
+      let s = document.activeElement ? c.indexOf(document.activeElement) : 0;
+      s === -1 || !u && s + 1 === c.length ? s = 0 : u && s === 0 ? s = c.length - 1 : s += u ? -1 : 1, c[s].focus();
+    };
+    t.addEventListener("keydown", o, !1);
+    let i;
+    {
+      const r = t.querySelector(e);
+      r && (i = setTimeout(() => {
+        r.focus({ preventScroll: !0 });
+      }, 100));
+    }
+    return () => {
+      t.removeEventListener("keydown", o), i !== void 0 && clearTimeout(i), n.current?.focus({ preventScroll: !0 });
+    };
+  }, [t, e]);
+}
+function X(t, e, n) {
+  const [o] = t.split("-");
+  switch (o) {
+    case "top":
+    case "bottom":
+      return {
+        width: e,
+        height: n
+      };
+    case "left":
+    case "right":
+      return {
+        width: n,
+        height: e
+      };
+    default:
+      return null;
+  }
+}
+function De(t, e, n) {
+  const [o] = t.split("-");
+  switch (o) {
+    case "top":
+      return {
+        points: `0,0 ${e / 2},${n} ${e},0`,
+        ...X(t, e, n)
+      };
+    case "bottom":
+      return {
+        points: `${e},${n} ${e / 2},0 0,${n}`,
+        ...X(t, e, n)
+      };
+    case "left":
+      return {
+        points: `0,0 ${n},${e / 2} 0,${e}`,
+        ...X(t, e, n)
+      };
+    case "right":
+      return {
+        points: `${n},${e} ${n},0 0,${e / 2}`,
+        ...X(t, e, n)
+      };
+    default:
+      return null;
+  }
+}
+function Fe(t, e, n, o) {
+  if (!e) return {};
+  const [i] = t.split("-");
+  switch (i) {
+    case "top":
+      return {
+        bottom: -n,
+        left: e.x ?? 0,
+        ...X(t, o, n)
+      };
+    case "bottom":
+      return {
+        top: -n,
+        left: e.x ?? 0,
+        ...X(t, o, n)
+      };
+    case "left":
+      return {
+        right: -n,
+        top: e.y ?? 0,
+        ...X(t, o, n)
+      };
+    case "right":
+      return {
+        left: -n,
+        top: e.y ?? 0,
+        ...X(t, o, n)
+      };
+    default:
+      return {};
+  }
+}
+function $e({ arrowComponent: t, arrowRef: e, base: n, placement: o, position: i, size: r, styles: c }) {
+  const u = t;
+  let s = null;
+  if (u) {
+    if (!X(o, n, r)) return null;
+    s = /* @__PURE__ */ E.createElement("span", { style: { flexShrink: 0 } }, /* @__PURE__ */ E.createElement(u, {
+      base: n,
+      placement: o,
+      size: r
+    }));
+  } else {
+    const p = De(o, n, r);
+    if (!p) return null;
+    s = /* @__PURE__ */ E.createElement("svg", {
+      height: p.height,
+      width: p.width,
+      xmlns: "http://www.w3.org/2000/svg"
+    }, /* @__PURE__ */ E.createElement("polygon", {
+      fill: "currentColor",
+      points: p.points
+    }));
+  }
+  return /* @__PURE__ */ E.createElement("span", {
+    ref: e,
+    className: "react-joyride__arrow",
+    "data-testid": "arrow",
+    style: {
+      ...c,
+      ...Fe(o, i, r, n),
+      ...i ? {} : { visibility: "hidden" }
+    }
+  }, s);
+}
+function Ue(t) {
+  const { beaconComponent: e, continuous: n, index: o, isLastStep: i, locale: r, nonce: c, onInteract: u, shouldFocus: s, size: p, step: g, styles: f } = t, l = N(null), h = !!e;
+  F(() => {
+    if (h || document.getElementById("joyride-beacon-animation")) return st;
+    const v = document.createElement("style");
+    v.id = "joyride-beacon-animation", c && v.setAttribute("nonce", c), v.appendChild(document.createTextNode(`
+        @keyframes joyride-beacon-inner {
+          20% {
+            opacity: 0.9;
+          }
+
+          90% {
+            opacity: 0.7;
+          }
+        }
+
+        @keyframes joyride-beacon-outer {
+          0% {
+            transform: scale(1);
+          }
+
+          45% {
+            opacity: 0.7;
+            transform: scale(0.75);
+          }
+
+          100% {
+            opacity: 0.9;
+            transform: scale(1);
+          }
+        }
+      `)), document.head.appendChild(v);
+    const a = setTimeout(() => {
+      z.domElement(l.current) && s && l.current.focus();
+    }, 0);
+    return () => {
+      clearTimeout(a);
+      const m = document.getElementById("joyride-beacon-animation");
+      m?.parentNode && m.parentNode.removeChild(m);
+    };
+  }, [
+    h,
+    c,
+    s
+  ]);
+  const T = q(r.open);
+  let P;
+  if (e) {
+    const v = e;
+    P = /* @__PURE__ */ E.createElement(v, {
+      continuous: n,
+      index: o,
+      isLastStep: i,
+      size: p,
+      step: g
+    });
+  } else P = /* @__PURE__ */ E.createElement("span", { style: f.beacon }, /* @__PURE__ */ E.createElement("span", { style: f.beaconOuter }), /* @__PURE__ */ E.createElement("span", { style: f.beaconInner }));
+  return /* @__PURE__ */ E.createElement("button", {
+    ref: l,
+    "aria-label": T,
+    className: "react-joyride__beacon",
+    "data-testid": "button-beacon",
+    onClick: u,
+    onMouseEnter: u,
+    style: f.beaconWrapper,
+    title: T,
+    type: "button"
+  }, P);
+}
+function Me({ styles: t, ...e }) {
+  const { color: n, height: o, width: i, ...r } = t;
+  return /* @__PURE__ */ E.createElement("button", {
+    style: r,
+    type: "button",
+    ...e
+  }, /* @__PURE__ */ E.createElement("svg", {
+    height: typeof o == "number" ? `${o}px` : o,
+    preserveAspectRatio: "xMidYMid",
+    version: "1.1",
+    viewBox: "0 0 18 18",
+    width: typeof i == "number" ? `${i}px` : i,
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /* @__PURE__ */ E.createElement("g", null, /* @__PURE__ */ E.createElement("path", {
+    d: "M8.13911129,9.00268191 L0.171521827,17.0258467 C-0.0498027049,17.248715 -0.0498027049,17.6098394 0.171521827,17.8327545 C0.28204354,17.9443526 0.427188206,17.9998706 0.572051765,17.9998706 C0.71714958,17.9998706 0.862013139,17.9443526 0.972581703,17.8327545 L9.0000937,9.74924618 L17.0276057,17.8327545 C17.1384085,17.9443526 17.2832721,17.9998706 17.4281356,17.9998706 C17.5729992,17.9998706 17.718097,17.9443526 17.8286656,17.8327545 C18.0499901,17.6098862 18.0499901,17.2487618 17.8286656,17.0258467 L9.86135722,9.00268191 L17.8340066,0.973848225 C18.0553311,0.750979934 18.0553311,0.389855532 17.8340066,0.16694039 C17.6126821,-0.0556467968 17.254037,-0.0556467968 17.0329467,0.16694039 L9.00042166,8.25611765 L0.967006424,0.167268345 C0.745681892,-0.0553188426 0.387317931,-0.0553188426 0.165993399,0.167268345 C-0.0553311331,0.390136635 -0.0553311331,0.751261038 0.165993399,0.974176179 L8.13920499,9.00268191 L8.13911129,9.00268191 Z",
+    fill: n
+  }))));
+}
+function je(t) {
+  const { backProps: e, closeProps: n, index: o, isLastStep: i, primaryProps: r, skipProps: c, step: u, tooltipProps: s } = t, { buttons: p, content: g, styles: f, title: l } = u, h = {};
+  p.includes("primary") && (h.primary = /* @__PURE__ */ E.createElement("button", {
+    "data-testid": "button-primary",
+    style: f.buttonPrimary,
+    type: "button",
+    ...r
+  })), p.includes("skip") && !i && (h.skip = /* @__PURE__ */ E.createElement("button", {
+    "aria-live": "off",
+    "data-testid": "button-skip",
+    style: f.buttonSkip,
+    type: "button",
+    ...c
+  })), p.includes("back") && o > 0 && (h.back = /* @__PURE__ */ E.createElement("button", {
+    "data-testid": "button-back",
+    style: f.buttonBack,
+    type: "button",
+    ...e
+  })), h.close = p.includes("close") && /* @__PURE__ */ E.createElement(Me, {
+    "data-testid": "button-close",
+    styles: f.buttonClose,
+    ...n
+  });
+  const T = l ? {
+    "aria-labelledby": "joyride-tooltip-title",
+    "aria-describedby": "joyride-tooltip-content"
+  } : {
+    "aria-label": q(g),
+    "aria-describedby": "joyride-tooltip-content"
+  };
+  return /* @__PURE__ */ E.createElement("div", {
+    key: "JoyrideTooltip",
+    className: "react-joyride__tooltip",
+    "data-joyride-step": o,
+    ...u.id && { "data-joyride-id": u.id },
+    style: f.tooltip,
+    ...s,
+    ...T
+  }, /* @__PURE__ */ E.createElement("div", { style: f.tooltipContainer }, l && /* @__PURE__ */ E.createElement("h4", {
+    id: "joyride-tooltip-title",
+    style: f.tooltipTitle
+  }, l), /* @__PURE__ */ E.createElement("div", {
+    id: "joyride-tooltip-content",
+    style: f.tooltipContent
+  }, g)), p.some((P) => P === "back" || P === "primary" || P === "skip") && /* @__PURE__ */ E.createElement("div", { style: f.tooltipFooter }, /* @__PURE__ */ E.createElement("div", { style: f.tooltipFooterSpacer }, h.skip), h.back, h.primary), h.close);
+}
+function He(t) {
+  const { continuous: e, controls: n, index: o, isLastStep: i, size: r, step: c } = t, u = (a) => {
+    a.preventDefault(), n.prev(K.BUTTON_BACK);
+  }, s = (a) => {
+    a.preventDefault(), c.closeButtonAction === "skip" ? n.skip(K.BUTTON_CLOSE) : c.closeButtonAction === "replay" ? n.replay(K.BUTTON_CLOSE) : n.close(K.BUTTON_CLOSE);
+  }, p = (a) => {
+    if (a.preventDefault(), !e) {
+      n.close(K.BUTTON_PRIMARY);
+      return;
+    }
+    n.next(K.BUTTON_PRIMARY);
+  }, g = (a) => {
+    a.preventDefault(), n.skip(K.BUTTON_SKIP);
+  }, f = () => {
+    const { back: a, close: m, last: y, next: x, nextWithProgress: _, skip: $ } = c.locale, U = q(a), D = q(m), G = q(y), M = q(x), O = q($);
+    let S = m, b = D;
+    if (e) {
+      if (S = x, b = M, c.showProgress && !i) {
+        const C = q(_, {
+          step: o + 1,
+          steps: r
+        });
+        S = ft(_, o + 1, r), b = C;
+      }
+      i && (S = y, b = G);
+    }
+    return {
+      backProps: {
+        "aria-label": U,
+        children: a,
+        "data-action": "back",
+        onClick: u,
+        role: "button",
+        title: U
+      },
+      closeProps: {
+        "aria-label": D,
+        children: m,
+        "data-action": "close",
+        onClick: s,
+        role: "button",
+        title: D
+      },
+      primaryProps: {
+        "aria-label": b,
+        children: S,
+        "data-action": "primary",
+        onClick: p,
+        role: "button",
+        title: b
+      },
+      skipProps: {
+        "aria-label": O,
+        children: $,
+        "data-action": "skip",
+        onClick: g,
+        role: "button",
+        title: O
+      },
+      tooltipProps: {
+        "aria-modal": !0,
+        role: "alertdialog"
+      }
+    };
+  }, { arrowComponent: l, beaconComponent: h, tooltipComponent: T, ...P } = c;
+  let v;
+  if (T) {
+    const a = T;
+    v = /* @__PURE__ */ E.createElement(a, {
+      ...f(),
+      continuous: e,
+      controls: n,
+      index: o,
+      isLastStep: i,
+      size: r,
+      step: P
+    });
+  } else v = /* @__PURE__ */ E.createElement(je, {
+    ...f(),
+    continuous: e,
+    controls: n,
+    index: o,
+    isLastStep: i,
+    size: r,
+    step: P
+  });
+  return v;
+}
+function Ye(t) {
+  if (t.startsWith("left")) return ["top", "bottom"];
+  if (t.startsWith("right")) return ["bottom", "top"];
+}
+function ze(t, e, n) {
+  return t ? [Vt()] : e.floatingOptions?.flipOptions === !1 ? [] : [Jt({
+    crossAxis: !1,
+    fallbackPlacements: Ye(n),
+    padding: 20,
+    ...e.floatingOptions?.flipOptions
+  })];
+}
+function We(t) {
+  const { continuous: e, controls: n, index: o, lifecycle: i, nonce: r, open: c, portalElement: u, setPositionData: s, setTooltipRef: p, shouldScroll: g, size: f, step: l, target: h, updateState: T } = t, P = N(null), v = N({}), a = N({}), m = l.placement === "center", y = l.placement === "auto", x = J(() => ({ getBoundingClientRect: () => ({
+    x: window.innerWidth / 2,
+    y: window.innerHeight / 2,
+    top: window.innerHeight / 2,
+    left: window.innerWidth / 2,
+    bottom: window.innerHeight / 2,
+    right: window.innerWidth / 2,
+    width: 0,
+    height: 0
+  }) }), []), _ = J(() => vt(h) ? ot(h) : void 0, [h]), $ = J(() => rt(h), [h]), U = J(() => _ ? {
+    boundary: _,
+    rootBoundary: "viewport"
+  } : {}, [_]), D = m || y ? "bottom" : l.placement, G = m ? "fixed" : l.floatingOptions?.strategy ?? (l.isFixed || $ ? "fixed" : "absolute"), M = J(() => m ? [{
+    name: "center",
+    fn: ({ rects: L }) => ({
+      x: (window.innerWidth - L.floating.width) / 2,
+      y: (window.innerHeight - L.floating.height) / 2
+    })
+  }] : [
+    yt(({ placement: L }) => {
+      let j = "right";
+      L.startsWith("top") ? j = "top" : L.startsWith("bottom") ? j = "bottom" : L.startsWith("left") && (j = "left");
+      const tt = l.spotlightTarget ? 0 : l.spotlightPadding[j];
+      return l.offset + tt + (l.floatingOptions?.hideArrow ? 0 : l.arrowSize);
+    }, [
+      l.offset,
+      l.spotlightPadding,
+      l.spotlightTarget,
+      l.arrowSize,
+      l.floatingOptions?.hideArrow
+    ]),
+    ...ze(y, l, D),
+    Kt({
+      padding: 10,
+      ...U,
+      ...l.floatingOptions?.shiftOptions
+    }),
+    ...l.floatingOptions?.hideArrow ? [] : [Gt({
+      element: P,
+      padding: l.arrowSpacing
+    }, [l.arrowSpacing, l.arrowBase])],
+    ...l.floatingOptions?.middleware ?? []
+  ], [
+    m,
+    l,
+    y,
+    D,
+    U
+  ]), O = Et({
+    ...m ? { elements: { reference: x } } : {},
+    placement: D,
+    strategy: G,
+    middleware: M
+  }), S = Et({
+    strategy: G,
+    placement: l.beaconPlacement ?? (y || m ? "bottom" : l.placement),
+    middleware: J(() => [yt(l.floatingOptions?.beaconOptions?.offset ?? -18)], [l.floatingOptions?.beaconOptions?.offset]),
+    whileElementsMounted: Tt
+  });
+  a.current = O.middlewareData, v.current = S.middlewareData, F(() => {
+    const { floating: L, reference: j } = O.elements;
+    if (!(!j || !L || i !== d.TOOLTIP))
+      return Tt(j, L, O.update, l.floatingOptions?.autoUpdate);
+  }, [
+    i,
+    O.update,
+    l.floatingOptions?.autoUpdate,
+    l.target,
+    O.elements
+  ]), F(() => {
+    !m && h && O.refs.setReference(h), h && S.refs.setReference(h);
+  }, [
+    S.refs,
+    m,
+    h,
+    O.refs
+  ]), F(() => {
+    O.isPositioned && s("tooltip", {
+      placement: O.placement,
+      x: O.x ?? 0,
+      y: O.y ?? 0,
+      middlewareData: a.current
+    });
+  }, [
+    s,
+    O.isPositioned,
+    O.placement,
+    O.x,
+    O.y
+  ]), F(() => {
+    S.isPositioned && s("beacon", {
+      placement: S.placement,
+      x: S.x ?? 0,
+      y: S.y ?? 0,
+      middlewareData: v.current
+    });
+  }, [
+    s,
+    S.isPositioned,
+    S.placement,
+    S.x,
+    S.y
+  ]);
+  const b = l.zIndex + 1, C = Q((L) => {
+    L.type === "mouseenter" && l.beaconTrigger !== "hover" || T({
+      lifecycle: d.TOOLTIP_BEFORE,
+      positioned: !1
+    });
+  }, [l.beaconTrigger, T]), A = Q((L) => {
+    L && (O.refs.setFloating(L), p(L));
+  }, [O.refs, p]), { arrow: B, floater: I } = l.styles;
+  let k = null;
+  if (i === d.TOOLTIP || i === d.TOOLTIP_BEFORE) {
+    const L = St({
+      ...I,
+      ...O.floatingStyles,
+      zIndex: b,
+      opacity: c && O.isPositioned ? 1 : 0,
+      ...!c && { transition: "none" }
+    });
+    k = /* @__PURE__ */ E.createElement("div", {
+      ref: A,
+      className: "react-joyride__floater",
+      "data-testid": "floater",
+      id: `react-joyride-step-${o}`,
+      style: L
+    }, /* @__PURE__ */ E.createElement(He, {
+      continuous: e,
+      controls: n,
+      index: o,
+      isLastStep: o + 1 === f,
+      size: f,
+      step: l
+    }), !m && !l.floatingOptions?.hideArrow && /* @__PURE__ */ E.createElement($e, {
+      arrowComponent: l.arrowComponent,
+      arrowRef: P,
+      base: l.arrowBase,
+      placement: O.placement,
+      position: O.middlewareData.arrow,
+      size: l.arrowSize,
+      styles: B
+    }));
+  } else (i === d.BEACON || i === d.BEACON_BEFORE) && (k = /* @__PURE__ */ E.createElement("div", {
+    ref: S.refs.setFloating,
+    className: "react-joyride__floater",
+    "data-testid": "floater-beacon",
+    id: `react-joyride-step-${o}-beacon`,
+    style: St({
+      ...S.floatingStyles,
+      zIndex: b
+    })
+  }, /* @__PURE__ */ E.createElement(Ue, {
+    beaconComponent: l.beaconComponent,
+    continuous: e,
+    index: o,
+    isLastStep: o + 1 === f,
+    locale: l.locale,
+    nonce: r,
+    onInteract: C,
+    shouldFocus: g,
+    size: f,
+    step: l,
+    styles: l.styles
+  })));
+  return /* @__PURE__ */ E.createElement(Dt, { element: u }, k);
+}
+function Ke(t) {
+  const { continuous: e, controls: n, index: o, lifecycle: i, nonce: r, portalElement: c, setPositionData: u, shouldScroll: s, size: p, step: g, updateState: f } = t, [l, h] = nt(null);
+  _e(g.disableFocusTrap ? null : l, "[data-action=primary]");
+  const T = V(g.target), P = i === d.TOOLTIP;
+  return !Bt(g) || !z.domElement(T) ? null : /* @__PURE__ */ E.createElement(We, {
+    key: `JoyrideStep-${o}`,
+    continuous: e,
+    controls: n,
+    index: o,
+    lifecycle: i,
+    nonce: r,
+    open: P,
+    portalElement: c,
+    setPositionData: u,
+    setTooltipRef: h,
+    shouldScroll: s,
+    size: p,
+    step: g,
+    target: T,
+    updateState: f
+  });
+}
+function Ge({ controls: t, mergedProps: e, state: n, step: o, store: i }) {
+  const { continuous: r, debug: c, nonce: u, portalElement: s, scrollToFirstStep: p } = e, g = Pe(s), { index: f, lifecycle: l, status: h } = n, T = h === w.RUNNING, [P, v] = nt(!1), a = N(null), m = o?.loaderDelay ?? 0;
+  F(() => (n.waiting ? m === 0 ? v(!0) : a.current = setTimeout(() => {
+    v(!0);
+  }, m) : v(!1), () => {
+    a.current && (clearTimeout(a.current), a.current = null);
+  }), [m, n.waiting]), F(() => {
+    if (!T) return;
+    const _ = ($) => {
+      !o || l !== d.TOOLTIP || $.key === "Escape" && o.dismissKeyAction && (o.dismissKeyAction === "next" ? t.next(K.KEYBOARD) : o.dismissKeyAction === "replay" ? t.replay(K.KEYBOARD) : t.close(K.KEYBOARD));
+    };
+    return document.body.addEventListener("keydown", _, { passive: !0 }), () => {
+      document.body.removeEventListener("keydown", _);
+    };
+  }, [
+    t,
+    T,
+    l,
+    o
+  ]);
+  const y = Q(() => {
+    switch (o?.overlayClickAction) {
+      case "close":
+        t.close(K.OVERLAY);
+        break;
+      case "next":
+        t.next(K.OVERLAY);
+        break;
+      case "replay":
+        t.replay(K.OVERLAY);
+        break;
+    }
+  }, [t, o?.overlayClickAction]);
+  if (!o || !T) return null;
+  const x = n.action === R.START && !o.skipBeacon && o.placement !== "center";
+  return /* @__PURE__ */ E.createElement(E.Fragment, null, l !== d.INIT && /* @__PURE__ */ E.createElement(Ke, {
+    ...n,
+    continuous: r,
+    controls: t,
+    debug: c,
+    nonce: u,
+    portalElement: g,
+    setPositionData: i.current.setPositionData,
+    shouldScroll: !o.skipScroll && (f !== 0 || p),
+    step: o,
+    updateState: i.current.updateState
+  }), /* @__PURE__ */ E.createElement(Dt, { element: g }, /* @__PURE__ */ E.createElement(E.Fragment, null, P && /* @__PURE__ */ E.createElement(Ie, {
+    nonce: u,
+    step: o
+  }), !x && /* @__PURE__ */ E.createElement(ke, {
+    ...o,
+    continuous: r,
+    lifecycle: l,
+    onClickOverlay: y,
+    portalElement: s ? g : null,
+    scrolling: n.scrolling,
+    waiting: n.waiting
+  }))));
+}
+function Ve(t) {
+  const { controls: e, failures: n, mergedProps: o, state: i, step: r, store: c } = we(t);
+  return {
+    controls: e,
+    failures: n,
+    on: Q((u, s) => c.current.on(u, s), [c]),
+    state: J(() => at(i, "positioned"), [i]),
+    step: r,
+    Tour: pt() ? /* @__PURE__ */ E.createElement(Ge, {
+      controls: e,
+      mergedProps: o,
+      state: i,
+      step: r,
+      store: c
+    }) : null
+  };
+}
+function Je(t) {
+  const { Tour: e } = Ve(t);
+  return e;
+}
+function an(t) {
+  return pt() ? /* @__PURE__ */ E.createElement(Je, t) : null;
+}
+export {
+  R as ACTIONS,
+  H as EVENTS,
+  an as Joyride,
+  d as LIFECYCLE,
+  K as ORIGIN,
+  te as PORTAL_ELEMENT_ID,
+  w as STATUS,
+  At as defaultLocale,
+  qt as defaultOptions,
+  Ve as useJoyride
+};