react-shepherd 4.2.0 → 5.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,4132 @@
+import Yn, { createContext as Yr, useContext as qr } from "react";
+var Rt = { exports: {} }, Ne = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var gn;
+function Kr() {
+  if (gn)
+    return Ne;
+  gn = 1;
+  var e = Yn, t = Symbol.for("react.element"), n = Symbol.for("react.fragment"), r = Object.prototype.hasOwnProperty, o = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, i = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function s(c, l, u) {
+    var f, h = {}, d = null, m = null;
+    u !== void 0 && (d = "" + u), l.key !== void 0 && (d = "" + l.key), l.ref !== void 0 && (m = l.ref);
+    for (f in l)
+      r.call(l, f) && !i.hasOwnProperty(f) && (h[f] = l[f]);
+    if (c && c.defaultProps)
+      for (f in l = c.defaultProps, l)
+        h[f] === void 0 && (h[f] = l[f]);
+    return { $$typeof: t, type: c, key: d, ref: m, props: h, _owner: o.current };
+  }
+  return Ne.Fragment = n, Ne.jsx = s, Ne.jsxs = s, Ne;
+}
+var Ve = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var bn;
+function zr() {
+  return bn || (bn = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = Yn, t = Symbol.for("react.element"), n = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), c = Symbol.for("react.context"), l = Symbol.for("react.forward_ref"), u = Symbol.for("react.suspense"), f = Symbol.for("react.suspense_list"), h = Symbol.for("react.memo"), d = Symbol.for("react.lazy"), m = Symbol.for("react.offscreen"), y = Symbol.iterator, E = "@@iterator";
+    function S(a) {
+      if (a === null || typeof a != "object")
+        return null;
+      var p = y && a[y] || a[E];
+      return typeof p == "function" ? p : null;
+    }
+    var w = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function _(a) {
+      {
+        for (var p = arguments.length, b = new Array(p > 1 ? p - 1 : 0), x = 1; x < p; x++)
+          b[x - 1] = arguments[x];
+        C("error", a, b);
+      }
+    }
+    function C(a, p, b) {
+      {
+        var x = w.ReactDebugCurrentFrame, P = x.getStackAddendum();
+        P !== "" && (p += "%s", b = b.concat([P]));
+        var k = b.map(function(R) {
+          return String(R);
+        });
+        k.unshift("Warning: " + p), Function.prototype.apply.call(console[a], console, k);
+      }
+    }
+    var v = !1, g = !1, T = !1, N = !1, te = !1, $;
+    $ = Symbol.for("react.module.reference");
+    function H(a) {
+      return !!(typeof a == "string" || typeof a == "function" || a === r || a === i || te || a === o || a === u || a === f || N || a === m || v || g || T || typeof a == "object" && a !== null && (a.$$typeof === d || a.$$typeof === h || a.$$typeof === s || a.$$typeof === c || a.$$typeof === l || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      a.$$typeof === $ || a.getModuleId !== void 0));
+    }
+    function z(a, p, b) {
+      var x = a.displayName;
+      if (x)
+        return x;
+      var P = p.displayName || p.name || "";
+      return P !== "" ? b + "(" + P + ")" : b;
+    }
+    function J(a) {
+      return a.displayName || "Context";
+    }
+    function W(a) {
+      if (a == null)
+        return null;
+      if (typeof a.tag == "number" && _("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof a == "function")
+        return a.displayName || a.name || null;
+      if (typeof a == "string")
+        return a;
+      switch (a) {
+        case r:
+          return "Fragment";
+        case n:
+          return "Portal";
+        case i:
+          return "Profiler";
+        case o:
+          return "StrictMode";
+        case u:
+          return "Suspense";
+        case f:
+          return "SuspenseList";
+      }
+      if (typeof a == "object")
+        switch (a.$$typeof) {
+          case c:
+            var p = a;
+            return J(p) + ".Consumer";
+          case s:
+            var b = a;
+            return J(b._context) + ".Provider";
+          case l:
+            return z(a, a.render, "ForwardRef");
+          case h:
+            var x = a.displayName || null;
+            return x !== null ? x : W(a.type) || "Memo";
+          case d: {
+            var P = a, k = P._payload, R = P._init;
+            try {
+              return W(R(k));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var M = Object.assign, G = 0, X, Y, se, he, Xe, Zt, Qt;
+    function en() {
+    }
+    en.__reactDisabledLog = !0;
+    function wr() {
+      {
+        if (G === 0) {
+          X = console.log, Y = console.info, se = console.warn, he = console.error, Xe = console.group, Zt = console.groupCollapsed, Qt = console.groupEnd;
+          var a = {
+            configurable: !0,
+            enumerable: !0,
+            value: en,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: a,
+            log: a,
+            warn: a,
+            error: a,
+            group: a,
+            groupCollapsed: a,
+            groupEnd: a
+          });
+        }
+        G++;
+      }
+    }
+    function _r() {
+      {
+        if (G--, G === 0) {
+          var a = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: M({}, a, {
+              value: X
+            }),
+            info: M({}, a, {
+              value: Y
+            }),
+            warn: M({}, a, {
+              value: se
+            }),
+            error: M({}, a, {
+              value: he
+            }),
+            group: M({}, a, {
+              value: Xe
+            }),
+            groupCollapsed: M({}, a, {
+              value: Zt
+            }),
+            groupEnd: M({}, a, {
+              value: Qt
+            })
+          });
+        }
+        G < 0 && _("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var mt = w.ReactCurrentDispatcher, gt;
+    function Ze(a, p, b) {
+      {
+        if (gt === void 0)
+          try {
+            throw Error();
+          } catch (P) {
+            var x = P.stack.trim().match(/\n( *(at )?)/);
+            gt = x && x[1] || "";
+          }
+        return `
+` + gt + a;
+      }
+    }
+    var bt = !1, Qe;
+    {
+      var Er = typeof WeakMap == "function" ? WeakMap : Map;
+      Qe = new Er();
+    }
+    function tn(a, p) {
+      if (!a || bt)
+        return "";
+      {
+        var b = Qe.get(a);
+        if (b !== void 0)
+          return b;
+      }
+      var x;
+      bt = !0;
+      var P = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var k;
+      k = mt.current, mt.current = null, wr();
+      try {
+        if (p) {
+          var R = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(R.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(R, []);
+            } catch (ae) {
+              x = ae;
+            }
+            Reflect.construct(a, [], R);
+          } else {
+            try {
+              R.call();
+            } catch (ae) {
+              x = ae;
+            }
+            a.call(R.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (ae) {
+            x = ae;
+          }
+          a();
+        }
+      } catch (ae) {
+        if (ae && x && typeof ae.stack == "string") {
+          for (var O = ae.stack.split(`
+`), U = x.stack.split(`
+`), D = O.length - 1, j = U.length - 1; D >= 1 && j >= 0 && O[D] !== U[j]; )
+            j--;
+          for (; D >= 1 && j >= 0; D--, j--)
+            if (O[D] !== U[j]) {
+              if (D !== 1 || j !== 1)
+                do
+                  if (D--, j--, j < 0 || O[D] !== U[j]) {
+                    var Z = `
+` + O[D].replace(" at new ", " at ");
+                    return a.displayName && Z.includes("<anonymous>") && (Z = Z.replace("<anonymous>", a.displayName)), typeof a == "function" && Qe.set(a, Z), Z;
+                  }
+                while (D >= 1 && j >= 0);
+              break;
+            }
+        }
+      } finally {
+        bt = !1, mt.current = k, _r(), Error.prepareStackTrace = P;
+      }
+      var Pe = a ? a.displayName || a.name : "", mn = Pe ? Ze(Pe) : "";
+      return typeof a == "function" && Qe.set(a, mn), mn;
+    }
+    function xr(a, p, b) {
+      return tn(a, !1);
+    }
+    function Sr(a) {
+      var p = a.prototype;
+      return !!(p && p.isReactComponent);
+    }
+    function et(a, p, b) {
+      if (a == null)
+        return "";
+      if (typeof a == "function")
+        return tn(a, Sr(a));
+      if (typeof a == "string")
+        return Ze(a);
+      switch (a) {
+        case u:
+          return Ze("Suspense");
+        case f:
+          return Ze("SuspenseList");
+      }
+      if (typeof a == "object")
+        switch (a.$$typeof) {
+          case l:
+            return xr(a.render);
+          case h:
+            return et(a.type, p, b);
+          case d: {
+            var x = a, P = x._payload, k = x._init;
+            try {
+              return et(k(P), p, b);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var tt = Object.prototype.hasOwnProperty, nn = {}, rn = w.ReactDebugCurrentFrame;
+    function nt(a) {
+      if (a) {
+        var p = a._owner, b = et(a.type, a._source, p ? p.type : null);
+        rn.setExtraStackFrame(b);
+      } else
+        rn.setExtraStackFrame(null);
+    }
+    function Or(a, p, b, x, P) {
+      {
+        var k = Function.call.bind(tt);
+        for (var R in a)
+          if (k(a, R)) {
+            var O = void 0;
+            try {
+              if (typeof a[R] != "function") {
+                var U = Error((x || "React class") + ": " + b + " type `" + R + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof a[R] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw U.name = "Invariant Violation", U;
+              }
+              O = a[R](p, R, x, b, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (D) {
+              O = D;
+            }
+            O && !(O instanceof Error) && (nt(P), _("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", x || "React class", b, R, typeof O), nt(null)), O instanceof Error && !(O.message in nn) && (nn[O.message] = !0, nt(P), _("Failed %s type: %s", b, O.message), nt(null));
+          }
+      }
+    }
+    var Cr = Array.isArray;
+    function yt(a) {
+      return Cr(a);
+    }
+    function Tr(a) {
+      {
+        var p = typeof Symbol == "function" && Symbol.toStringTag, b = p && a[Symbol.toStringTag] || a.constructor.name || "Object";
+        return b;
+      }
+    }
+    function Rr(a) {
+      try {
+        return on(a), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function on(a) {
+      return "" + a;
+    }
+    function sn(a) {
+      if (Rr(a))
+        return _("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Tr(a)), on(a);
+    }
+    var We = w.ReactCurrentOwner, Pr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, an, cn, vt;
+    vt = {};
+    function Ir(a) {
+      if (tt.call(a, "ref")) {
+        var p = Object.getOwnPropertyDescriptor(a, "ref").get;
+        if (p && p.isReactWarning)
+          return !1;
+      }
+      return a.ref !== void 0;
+    }
+    function kr(a) {
+      if (tt.call(a, "key")) {
+        var p = Object.getOwnPropertyDescriptor(a, "key").get;
+        if (p && p.isReactWarning)
+          return !1;
+      }
+      return a.key !== void 0;
+    }
+    function Ar(a, p) {
+      if (typeof a.ref == "string" && We.current && p && We.current.stateNode !== p) {
+        var b = W(We.current.type);
+        vt[b] || (_('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', W(We.current.type), a.ref), vt[b] = !0);
+      }
+    }
+    function Mr(a, p) {
+      {
+        var b = function() {
+          an || (an = !0, _("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", p));
+        };
+        b.isReactWarning = !0, Object.defineProperty(a, "key", {
+          get: b,
+          configurable: !0
+        });
+      }
+    }
+    function Dr(a, p) {
+      {
+        var b = function() {
+          cn || (cn = !0, _("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", p));
+        };
+        b.isReactWarning = !0, Object.defineProperty(a, "ref", {
+          get: b,
+          configurable: !0
+        });
+      }
+    }
+    var Fr = function(a, p, b, x, P, k, R) {
+      var O = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: a,
+        key: p,
+        ref: b,
+        props: R,
+        // Record the component responsible for creating this element.
+        _owner: k
+      };
+      return O._store = {}, Object.defineProperty(O._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(O, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: x
+      }), Object.defineProperty(O, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: P
+      }), Object.freeze && (Object.freeze(O.props), Object.freeze(O)), O;
+    };
+    function Lr(a, p, b, x, P) {
+      {
+        var k, R = {}, O = null, U = null;
+        b !== void 0 && (sn(b), O = "" + b), kr(p) && (sn(p.key), O = "" + p.key), Ir(p) && (U = p.ref, Ar(p, P));
+        for (k in p)
+          tt.call(p, k) && !Pr.hasOwnProperty(k) && (R[k] = p[k]);
+        if (a && a.defaultProps) {
+          var D = a.defaultProps;
+          for (k in D)
+            R[k] === void 0 && (R[k] = D[k]);
+        }
+        if (O || U) {
+          var j = typeof a == "function" ? a.displayName || a.name || "Unknown" : a;
+          O && Mr(R, j), U && Dr(R, j);
+        }
+        return Fr(a, O, U, P, x, We.current, R);
+      }
+    }
+    var wt = w.ReactCurrentOwner, ln = w.ReactDebugCurrentFrame;
+    function Re(a) {
+      if (a) {
+        var p = a._owner, b = et(a.type, a._source, p ? p.type : null);
+        ln.setExtraStackFrame(b);
+      } else
+        ln.setExtraStackFrame(null);
+    }
+    var _t;
+    _t = !1;
+    function Et(a) {
+      return typeof a == "object" && a !== null && a.$$typeof === t;
+    }
+    function un() {
+      {
+        if (wt.current) {
+          var a = W(wt.current.type);
+          if (a)
+            return `
+
+Check the render method of \`` + a + "`.";
+        }
+        return "";
+      }
+    }
+    function jr(a) {
+      {
+        if (a !== void 0) {
+          var p = a.fileName.replace(/^.*[\\\/]/, ""), b = a.lineNumber;
+          return `
+
+Check your code at ` + p + ":" + b + ".";
+        }
+        return "";
+      }
+    }
+    var fn = {};
+    function Br(a) {
+      {
+        var p = un();
+        if (!p) {
+          var b = typeof a == "string" ? a : a.displayName || a.name;
+          b && (p = `
+
+Check the top-level render call using <` + b + ">.");
+        }
+        return p;
+      }
+    }
+    function dn(a, p) {
+      {
+        if (!a._store || a._store.validated || a.key != null)
+          return;
+        a._store.validated = !0;
+        var b = Br(p);
+        if (fn[b])
+          return;
+        fn[b] = !0;
+        var x = "";
+        a && a._owner && a._owner !== wt.current && (x = " It was passed a child from " + W(a._owner.type) + "."), Re(a), _('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', b, x), Re(null);
+      }
+    }
+    function hn(a, p) {
+      {
+        if (typeof a != "object")
+          return;
+        if (yt(a))
+          for (var b = 0; b < a.length; b++) {
+            var x = a[b];
+            Et(x) && dn(x, p);
+          }
+        else if (Et(a))
+          a._store && (a._store.validated = !0);
+        else if (a) {
+          var P = S(a);
+          if (typeof P == "function" && P !== a.entries)
+            for (var k = P.call(a), R; !(R = k.next()).done; )
+              Et(R.value) && dn(R.value, p);
+        }
+      }
+    }
+    function $r(a) {
+      {
+        var p = a.type;
+        if (p == null || typeof p == "string")
+          return;
+        var b;
+        if (typeof p == "function")
+          b = p.propTypes;
+        else if (typeof p == "object" && (p.$$typeof === l || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        p.$$typeof === h))
+          b = p.propTypes;
+        else
+          return;
+        if (b) {
+          var x = W(p);
+          Or(b, a.props, "prop", x, a);
+        } else if (p.PropTypes !== void 0 && !_t) {
+          _t = !0;
+          var P = W(p);
+          _("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", P || "Unknown");
+        }
+        typeof p.getDefaultProps == "function" && !p.getDefaultProps.isReactClassApproved && _("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Wr(a) {
+      {
+        for (var p = Object.keys(a.props), b = 0; b < p.length; b++) {
+          var x = p[b];
+          if (x !== "children" && x !== "key") {
+            Re(a), _("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", x), Re(null);
+            break;
+          }
+        }
+        a.ref !== null && (Re(a), _("Invalid attribute `ref` supplied to `React.Fragment`."), Re(null));
+      }
+    }
+    function pn(a, p, b, x, P, k) {
+      {
+        var R = H(a);
+        if (!R) {
+          var O = "";
+          (a === void 0 || typeof a == "object" && a !== null && Object.keys(a).length === 0) && (O += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var U = jr(P);
+          U ? O += U : O += un();
+          var D;
+          a === null ? D = "null" : yt(a) ? D = "array" : a !== void 0 && a.$$typeof === t ? (D = "<" + (W(a.type) || "Unknown") + " />", O = " Did you accidentally export a JSX literal instead of a component?") : D = typeof a, _("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", D, O);
+        }
+        var j = Lr(a, p, b, P, k);
+        if (j == null)
+          return j;
+        if (R) {
+          var Z = p.children;
+          if (Z !== void 0)
+            if (x)
+              if (yt(Z)) {
+                for (var Pe = 0; Pe < Z.length; Pe++)
+                  hn(Z[Pe], a);
+                Object.freeze && Object.freeze(Z);
+              } else
+                _("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              hn(Z, a);
+        }
+        return a === r ? Wr(j) : $r(j), j;
+      }
+    }
+    function Nr(a, p, b) {
+      return pn(a, p, b, !0);
+    }
+    function Vr(a, p, b) {
+      return pn(a, p, b, !1);
+    }
+    var Ur = Vr, Hr = Nr;
+    Ve.Fragment = r, Ve.jsx = Ur, Ve.jsxs = Hr;
+  }()), Ve;
+}
+process.env.NODE_ENV === "production" ? Rt.exports = Kr() : Rt.exports = zr();
+var Jr = Rt.exports;
+/*! shepherd.js 12.0.0-alpha.13 */
+function Gr(e) {
+  return e instanceof Element;
+}
+function ze(e) {
+  return e instanceof HTMLElement;
+}
+function pe(e) {
+  return typeof e == "function";
+}
+function Ye(e) {
+  return typeof e == "string";
+}
+function V(e) {
+  return e === void 0;
+}
+class Nt {
+  /**
+   * Adds an event listener for the given event string.
+   *
+   * @param {string} event
+   * @param {Function} handler
+   * @param ctx
+   * @param {boolean} once
+   * @returns
+   */
+  on(t, n, r, o = !1) {
+    var i;
+    return V(this.bindings) && (this.bindings = {}), V(this.bindings[t]) && (this.bindings[t] = []), (i = this.bindings[t]) == null || i.push({ handler: n, ctx: r, once: o }), this;
+  }
+  /**
+   * Adds an event listener that only fires once for the given event string.
+   *
+   * @param {string} event
+   * @param {Function} handler
+   * @param ctx
+   * @returns
+   */
+  once(t, n, r) {
+    return this.on(t, n, r, !0);
+  }
+  /**
+   * Removes an event listener for the given event string.
+   *
+   * @param {string} event
+   * @param {Function} handler
+   * @returns
+   */
+  off(t, n) {
+    var r;
+    return V(this.bindings) || V(this.bindings[t]) ? this : (V(n) ? delete this.bindings[t] : (r = this.bindings[t]) == null || r.forEach((o, i) => {
+      var s;
+      o.handler === n && ((s = this.bindings[t]) == null || s.splice(i, 1));
+    }), this);
+  }
+  /**
+   * Triggers an event listener for the given event string.
+   *
+   * @param {string} event
+   * @returns
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  trigger(t, ...n) {
+    var r;
+    return !V(this.bindings) && this.bindings[t] && ((r = this.bindings[t]) == null || r.forEach((o, i) => {
+      var f;
+      const { ctx: s, handler: c, once: l } = o, u = s || this;
+      c.apply(u, n), l && ((f = this.bindings[t]) == null || f.splice(i, 1));
+    })), this;
+  }
+}
+function Ue(e) {
+  var t, n;
+  function r(i, s) {
+    try {
+      var c = e[i](s), l = c.value, u = l instanceof qn;
+      Promise.resolve(u ? l.v : l).then(function(f) {
+        if (u) {
+          var h = i === "return" ? "return" : "next";
+          if (!l.k || f.done)
+            return r(h, f);
+          f = e[h](f).value;
+        }
+        o(c.done ? "return" : "normal", f);
+      }, function(f) {
+        r("throw", f);
+      });
+    } catch (f) {
+      o("throw", f);
+    }
+  }
+  function o(i, s) {
+    switch (i) {
+      case "return":
+        t.resolve({
+          value: s,
+          done: !0
+        });
+        break;
+      case "throw":
+        t.reject(s);
+        break;
+      default:
+        t.resolve({
+          value: s,
+          done: !1
+        });
+    }
+    (t = t.next) ? r(t.key, t.arg) : n = null;
+  }
+  this._invoke = function(i, s) {
+    return new Promise(function(c, l) {
+      var u = {
+        key: i,
+        arg: s,
+        resolve: c,
+        reject: l,
+        next: null
+      };
+      n ? n = n.next = u : (t = n = u, r(i, s));
+    });
+  }, typeof e.return != "function" && (this.return = void 0);
+}
+Ue.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+  return this;
+}, Ue.prototype.next = function(e) {
+  return this._invoke("next", e);
+}, Ue.prototype.throw = function(e) {
+  return this._invoke("throw", e);
+}, Ue.prototype.return = function(e) {
+  return this._invoke("return", e);
+};
+function qn(e, t) {
+  this.v = e, this.k = t;
+}
+function yn(e) {
+  return new qn(e, 0);
+}
+function Xr(e) {
+  return function() {
+    return new Ue(e.apply(this, arguments));
+  };
+}
+function B() {
+  return B = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n)
+        Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, B.apply(this, arguments);
+}
+function Kn(e, t) {
+  if (e == null)
+    return {};
+  var n = {}, r = Object.keys(e), o, i;
+  for (i = 0; i < r.length; i++)
+    o = r[i], !(t.indexOf(o) >= 0) && (n[o] = e[o]);
+  return n;
+}
+const be = {
+  defaultMerge: Symbol("deepmerge-ts: default merge"),
+  skip: Symbol("deepmerge-ts: skip")
+};
+be.defaultMerge;
+function Zr(e, t) {
+  return t;
+}
+function vn(e) {
+  return typeof e != "object" || e === null ? 0 : Array.isArray(e) ? 2 : to(e) ? 1 : e instanceof Set ? 3 : e instanceof Map ? 4 : 5;
+}
+function Qr(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of e)
+    for (const r of [...Object.keys(n), ...Object.getOwnPropertySymbols(n)])
+      t.add(r);
+  return t;
+}
+function eo(e, t) {
+  return typeof e == "object" && Object.prototype.propertyIsEnumerable.call(e, t);
+}
+function zn(e) {
+  return {
+    // eslint-disable-next-line functional/functional-parameters
+    *[Symbol.iterator]() {
+      for (const t of e)
+        for (const n of t)
+          yield n;
+    }
+  };
+}
+const wn = /* @__PURE__ */ new Set(["[object Object]", "[object Module]"]);
+function to(e) {
+  if (!wn.has(Object.prototype.toString.call(e)))
+    return !1;
+  const {
+    constructor: t
+  } = e;
+  if (t === void 0)
+    return !0;
+  const n = t.prototype;
+  return !(n === null || typeof n != "object" || !wn.has(Object.prototype.toString.call(n)) || !n.hasOwnProperty("isPrototypeOf"));
+}
+function no(e, t, n) {
+  const r = {};
+  for (const o of Qr(e)) {
+    const i = [];
+    for (const l of e)
+      eo(l, o) && i.push(l[o]);
+    if (i.length === 0)
+      continue;
+    const s = t.metaDataUpdater(n, {
+      key: o,
+      parents: e
+    }), c = Gn(i, t, s);
+    c !== be.skip && (o === "__proto__" ? Object.defineProperty(r, o, {
+      value: c,
+      configurable: !0,
+      enumerable: !0,
+      writable: !0
+    }) : r[o] = c);
+  }
+  return r;
+}
+function ro(e) {
+  return e.flat();
+}
+function oo(e) {
+  return new Set(zn(e));
+}
+function io(e) {
+  return new Map(zn(e));
+}
+function Jn(e) {
+  return e.at(-1);
+}
+var xt = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  mergeArrays: ro,
+  mergeMaps: io,
+  mergeOthers: Jn,
+  mergeRecords: no,
+  mergeSets: oo
+});
+function Vt(...e) {
+  return so({})(...e);
+}
+function so(e, t) {
+  const n = ao(e, r);
+  function r(...o) {
+    return Gn(o, n, t);
+  }
+  return r;
+}
+function ao(e, t) {
+  var n, r;
+  return {
+    defaultMergeFunctions: xt,
+    mergeFunctions: B({}, xt, Object.fromEntries(Object.entries(e).filter(([o, i]) => Object.hasOwn(xt, o)).map(([o, i]) => i === !1 ? [o, Jn] : [o, i]))),
+    metaDataUpdater: (n = e.metaDataUpdater) != null ? n : Zr,
+    deepmerge: t,
+    useImplicitDefaultMerging: (r = e.enableImplicitDefaultMerging) != null ? r : !1,
+    actions: be
+  };
+}
+function Gn(e, t, n) {
+  if (e.length === 0)
+    return;
+  if (e.length === 1)
+    return St(e, t, n);
+  const r = vn(e[0]);
+  if (r !== 0 && r !== 5) {
+    for (let o = 1; o < e.length; o++)
+      if (vn(e[o]) !== r)
+        return St(e, t, n);
+  }
+  switch (r) {
+    case 1:
+      return co(e, t, n);
+    case 2:
+      return lo(e, t, n);
+    case 3:
+      return uo(e, t, n);
+    case 4:
+      return fo(e, t, n);
+    default:
+      return St(e, t, n);
+  }
+}
+function co(e, t, n) {
+  const r = t.mergeFunctions.mergeRecords(e, t, n);
+  return r === be.defaultMerge || t.useImplicitDefaultMerging && r === void 0 && t.mergeFunctions.mergeRecords !== t.defaultMergeFunctions.mergeRecords ? t.defaultMergeFunctions.mergeRecords(e, t, n) : r;
+}
+function lo(e, t, n) {
+  const r = t.mergeFunctions.mergeArrays(e, t, n);
+  return r === be.defaultMerge || t.useImplicitDefaultMerging && r === void 0 && t.mergeFunctions.mergeArrays !== t.defaultMergeFunctions.mergeArrays ? t.defaultMergeFunctions.mergeArrays(e) : r;
+}
+function uo(e, t, n) {
+  const r = t.mergeFunctions.mergeSets(e, t, n);
+  return r === be.defaultMerge || t.useImplicitDefaultMerging && r === void 0 && t.mergeFunctions.mergeSets !== t.defaultMergeFunctions.mergeSets ? t.defaultMergeFunctions.mergeSets(e) : r;
+}
+function fo(e, t, n) {
+  const r = t.mergeFunctions.mergeMaps(e, t, n);
+  return r === be.defaultMerge || t.useImplicitDefaultMerging && r === void 0 && t.mergeFunctions.mergeMaps !== t.defaultMergeFunctions.mergeMaps ? t.defaultMergeFunctions.mergeMaps(e) : r;
+}
+function St(e, t, n) {
+  const r = t.mergeFunctions.mergeOthers(e, t, n);
+  return r === be.defaultMerge || t.useImplicitDefaultMerging && r === void 0 && t.mergeFunctions.mergeOthers !== t.defaultMergeFunctions.mergeOthers ? t.defaultMergeFunctions.mergeOthers(e) : r;
+}
+function Xn(e) {
+  const t = Object.getOwnPropertyNames(e.constructor.prototype);
+  for (let n = 0; n < t.length; n++) {
+    const r = t[n], o = e[r];
+    r !== "constructor" && typeof o == "function" && (e[r] = o.bind(e));
+  }
+  return e;
+}
+function ho(e, t) {
+  return (n) => {
+    if (e.isOpen()) {
+      const r = e.el && n.currentTarget === e.el;
+      (!V(t) && n.currentTarget.matches(t) || r) && e.tour.next();
+    }
+  };
+}
+function po(e) {
+  const { event: t, selector: n } = e.options.advanceOn || {};
+  if (t) {
+    const r = ho(e, n);
+    let o = null;
+    if (!V(n) && (o = document.querySelector(n), !o))
+      return console.error(`No element was found for the selector supplied to advanceOn: ${n}`);
+    o ? (o.addEventListener(t, r), e.on("destroy", () => o.removeEventListener(t, r))) : (document.body.addEventListener(t, r, !0), e.on("destroy", () => document.body.removeEventListener(t, r, !0)));
+  } else
+    return console.error("advanceOn was defined, but no event name was passed.");
+}
+class mo {
+  constructor(t) {
+  }
+}
+class go {
+  constructor(t, n) {
+  }
+}
+function Zn(e) {
+  return !Ye(e) || e === "" ? "" : e.charAt(e.length - 1) !== "-" ? `${e}-` : e;
+}
+function bo(e) {
+  const t = e.options.attachTo || {}, n = Object.assign({}, t);
+  if (pe(n.element) && (n.element = n.element.call(e)), Ye(n.element)) {
+    try {
+      n.element = document.querySelector(n.element);
+    } catch {
+    }
+    n.element || console.error(`The element for this Shepherd step was not found ${t.element}`);
+  }
+  return n;
+}
+function Qn(e) {
+  return e == null ? !0 : !e.element || !e.on;
+}
+function er() {
+  let e = Date.now();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
+    const n = (e + Math.random() * 16) % 16 | 0;
+    return e = Math.floor(e / 16), (t == "x" ? n : n & 3 | 8).toString(16);
+  });
+}
+const Fe = Math.min, _e = Math.max, it = Math.round, rt = Math.floor, me = (e) => ({
+  x: e,
+  y: e
+}), yo = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, vo = {
+  start: "end",
+  end: "start"
+};
+function Pt(e, t, n) {
+  return _e(e, Fe(t, n));
+}
+function Le(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Oe(e) {
+  return e.split("-")[0];
+}
+function lt(e) {
+  return e.split("-")[1];
+}
+function Ut(e) {
+  return e === "x" ? "y" : "x";
+}
+function Ht(e) {
+  return e === "y" ? "height" : "width";
+}
+function ut(e) {
+  return ["top", "bottom"].includes(Oe(e)) ? "y" : "x";
+}
+function Yt(e) {
+  return Ut(ut(e));
+}
+function wo(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = lt(e), o = Yt(e), i = Ht(o);
+  let s = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = st(s)), [s, st(s)];
+}
+function _o(e) {
+  const t = st(e);
+  return [It(e), t, It(t)];
+}
+function It(e) {
+  return e.replace(/start|end/g, (t) => vo[t]);
+}
+function Eo(e, t, n) {
+  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], s = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? o : r : t ? r : o;
+    case "left":
+    case "right":
+      return t ? i : s;
+    default:
+      return [];
+  }
+}
+function xo(e, t, n, r) {
+  const o = lt(e);
+  let i = Eo(Oe(e), n === "start", r);
+  return o && (i = i.map((s) => s + "-" + o), t && (i = i.concat(i.map(It)))), i;
+}
+function st(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => yo[t]);
+}
+function So(e) {
+  return B({
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  }, e);
+}
+function tr(e) {
+  return typeof e != "number" ? So(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function at(e) {
+  return B({}, e, {
+    top: e.y,
+    left: e.x,
+    right: e.x + e.width,
+    bottom: e.y + e.height
+  });
+}
+const Oo = ["mainAxis", "crossAxis", "fallbackPlacements", "fallbackStrategy", "fallbackAxisSideDirection", "flipAlignment"], Co = ["mainAxis", "crossAxis", "limiter"];
+function _n(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const i = ut(t), s = Yt(t), c = Ht(s), l = Oe(t), u = i === "y", f = r.x + r.width / 2 - o.width / 2, h = r.y + r.height / 2 - o.height / 2, d = r[c] / 2 - o[c] / 2;
+  let m;
+  switch (l) {
+    case "top":
+      m = {
+        x: f,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      m = {
+        x: f,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      m = {
+        x: r.x + r.width,
+        y: h
+      };
+      break;
+    case "left":
+      m = {
+        x: r.x - o.width,
+        y: h
+      };
+      break;
+    default:
+      m = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (lt(t)) {
+    case "start":
+      m[s] -= d * (n && u ? -1 : 1);
+      break;
+    case "end":
+      m[s] += d * (n && u ? -1 : 1);
+      break;
+  }
+  return m;
+}
+const To = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, c = i.filter(Boolean), l = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let u = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: f,
+    y: h
+  } = _n(u, r, l), d = r, m = {}, y = 0;
+  for (let E = 0; E < c.length; E++) {
+    const {
+      name: S,
+      fn: w
+    } = c[E], {
+      x: _,
+      y: C,
+      data: v,
+      reset: g
+    } = await w({
+      x: f,
+      y: h,
+      initialPlacement: r,
+      placement: d,
+      strategy: o,
+      middlewareData: m,
+      rects: u,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    f = _ ?? f, h = C ?? h, m = B({}, m, {
+      [S]: B({}, m[S], v)
+    }), g && y <= 50 && (y++, typeof g == "object" && (g.placement && (d = g.placement), g.rects && (u = g.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : g.rects), {
+      x: f,
+      y: h
+    } = _n(u, d, l)), E = -1);
+  }
+  return {
+    x: f,
+    y: h,
+    placement: d,
+    strategy: o,
+    middlewareData: m
+  };
+};
+async function nr(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: s,
+    elements: c,
+    strategy: l
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: h = "floating",
+    altBoundary: d = !1,
+    padding: m = 0
+  } = Le(t, e), y = tr(m), S = c[d ? h === "floating" ? "reference" : "floating" : h], w = at(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(S))) == null || n ? S : S.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(c.floating)),
+    boundary: u,
+    rootBoundary: f,
+    strategy: l
+  })), _ = h === "floating" ? B({}, s.floating, {
+    x: r,
+    y: o
+  }) : s.reference, C = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(c.floating)), v = await (i.isElement == null ? void 0 : i.isElement(C)) ? await (i.getScale == null ? void 0 : i.getScale(C)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, g = at(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: _,
+    offsetParent: C,
+    strategy: l
+  }) : _);
+  return {
+    top: (w.top - g.top + y.top) / v.y,
+    bottom: (g.bottom - w.bottom + y.bottom) / v.y,
+    left: (w.left - g.left + y.left) / v.x,
+    right: (g.right - w.right + y.right) / v.x
+  };
+}
+const Ro = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: r,
+      placement: o,
+      rects: i,
+      platform: s,
+      elements: c,
+      middlewareData: l
+    } = t, {
+      element: u,
+      padding: f = 0
+    } = Le(e, t) || {};
+    if (u == null)
+      return {};
+    const h = tr(f), d = {
+      x: n,
+      y: r
+    }, m = Yt(o), y = Ht(m), E = await s.getDimensions(u), S = m === "y", w = S ? "top" : "left", _ = S ? "bottom" : "right", C = S ? "clientHeight" : "clientWidth", v = i.reference[y] + i.reference[m] - d[m] - i.floating[y], g = d[m] - i.reference[m], T = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let N = T ? T[C] : 0;
+    (!N || !await (s.isElement == null ? void 0 : s.isElement(T))) && (N = c.floating[C] || i.floating[y]);
+    const te = v / 2 - g / 2, $ = N / 2 - E[y] / 2 - 1, H = Fe(h[w], $), z = Fe(h[_], $), J = H, W = N - E[y] - z, M = N / 2 - E[y] / 2 + te, G = Pt(J, M, W), X = !l.arrow && lt(o) != null && M !== G && i.reference[y] / 2 - (M < J ? H : z) - E[y] / 2 < 0, Y = X ? M < J ? M - J : M - W : 0;
+    return {
+      [m]: d[m] + Y,
+      data: B({
+        [m]: G,
+        centerOffset: M - G - Y
+      }, X && {
+        alignmentOffset: Y
+      }),
+      reset: X
+    };
+  }
+}), Po = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(n) {
+      var r, o;
+      const {
+        placement: i,
+        middlewareData: s,
+        rects: c,
+        initialPlacement: l,
+        platform: u,
+        elements: f
+      } = n, h = Le(t, n), {
+        mainAxis: d = !0,
+        crossAxis: m = !0,
+        fallbackPlacements: y,
+        fallbackStrategy: E = "bestFit",
+        fallbackAxisSideDirection: S = "none",
+        flipAlignment: w = !0
+      } = h, _ = Kn(h, Oo);
+      if ((r = s.arrow) != null && r.alignmentOffset)
+        return {};
+      const C = Oe(i), v = Oe(l) === l, g = await (u.isRTL == null ? void 0 : u.isRTL(f.floating)), T = y || (v || !w ? [st(l)] : _o(l));
+      !y && S !== "none" && T.push(...xo(l, w, S, g));
+      const N = [l, ...T], te = await nr(n, _), $ = [];
+      let H = ((o = s.flip) == null ? void 0 : o.overflows) || [];
+      if (d && $.push(te[C]), m) {
+        const M = wo(i, c, g);
+        $.push(te[M[0]], te[M[1]]);
+      }
+      if (H = [...H, {
+        placement: i,
+        overflows: $
+      }], !$.every((M) => M <= 0)) {
+        var z, J;
+        const M = (((z = s.flip) == null ? void 0 : z.index) || 0) + 1, G = N[M];
+        if (G)
+          return {
+            data: {
+              index: M,
+              overflows: H
+            },
+            reset: {
+              placement: G
+            }
+          };
+        let X = (J = H.filter((Y) => Y.overflows[0] <= 0).sort((Y, se) => Y.overflows[1] - se.overflows[1])[0]) == null ? void 0 : J.placement;
+        if (!X)
+          switch (E) {
+            case "bestFit": {
+              var W;
+              const Y = (W = H.map((se) => [se.placement, se.overflows.filter((he) => he > 0).reduce((he, Xe) => he + Xe, 0)]).sort((se, he) => se[1] - he[1])[0]) == null ? void 0 : W[0];
+              Y && (X = Y);
+              break;
+            }
+            case "initialPlacement":
+              X = l;
+              break;
+          }
+        if (i !== X)
+          return {
+            reset: {
+              placement: X
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, Io = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(n) {
+      const {
+        x: r,
+        y: o,
+        placement: i
+      } = n, s = Le(t, n), {
+        mainAxis: c = !0,
+        crossAxis: l = !1,
+        limiter: u = {
+          fn: (_) => {
+            let {
+              x: C,
+              y: v
+            } = _;
+            return {
+              x: C,
+              y: v
+            };
+          }
+        }
+      } = s, f = Kn(s, Co), h = {
+        x: r,
+        y: o
+      }, d = await nr(n, f), m = ut(Oe(i)), y = Ut(m);
+      let E = h[y], S = h[m];
+      if (c) {
+        const _ = y === "y" ? "top" : "left", C = y === "y" ? "bottom" : "right", v = E + d[_], g = E - d[C];
+        E = Pt(v, E, g);
+      }
+      if (l) {
+        const _ = m === "y" ? "top" : "left", C = m === "y" ? "bottom" : "right", v = S + d[_], g = S - d[C];
+        S = Pt(v, S, g);
+      }
+      const w = u.fn(B({}, n, {
+        [y]: E,
+        [m]: S
+      }));
+      return B({}, w, {
+        data: {
+          x: w.x - r,
+          y: w.y - o
+        }
+      });
+    }
+  };
+}, ko = function(t) {
+  return t === void 0 && (t = {}), {
+    options: t,
+    fn(n) {
+      const {
+        x: r,
+        y: o,
+        placement: i,
+        rects: s,
+        middlewareData: c
+      } = n, {
+        offset: l = 0,
+        mainAxis: u = !0,
+        crossAxis: f = !0
+      } = Le(t, n), h = {
+        x: r,
+        y: o
+      }, d = ut(i), m = Ut(d);
+      let y = h[m], E = h[d];
+      const S = Le(l, n), w = typeof S == "number" ? {
+        mainAxis: S,
+        crossAxis: 0
+      } : B({
+        mainAxis: 0,
+        crossAxis: 0
+      }, S);
+      if (u) {
+        const v = m === "y" ? "height" : "width", g = s.reference[m] - s.floating[v] + w.mainAxis, T = s.reference[m] + s.reference[v] - w.mainAxis;
+        y < g ? y = g : y > T && (y = T);
+      }
+      if (f) {
+        var _, C;
+        const v = m === "y" ? "width" : "height", g = ["top", "left"].includes(Oe(i)), T = s.reference[d] - s.floating[v] + (g && ((_ = c.offset) == null ? void 0 : _[d]) || 0) + (g ? 0 : w.crossAxis), N = s.reference[d] + s.reference[v] + (g ? 0 : ((C = c.offset) == null ? void 0 : C[d]) || 0) - (g ? w.crossAxis : 0);
+        E < T ? E = T : E > N && (E = N);
+      }
+      return {
+        [m]: y,
+        [d]: E
+      };
+    }
+  };
+};
+function ge(e) {
+  return rr(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function q(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function le(e) {
+  var t;
+  return (t = (rr(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function rr(e) {
+  return e instanceof Node || e instanceof q(e).Node;
+}
+function ce(e) {
+  return e instanceof Element || e instanceof q(e).Element;
+}
+function oe(e) {
+  return e instanceof HTMLElement || e instanceof q(e).HTMLElement;
+}
+function En(e) {
+  return typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof q(e).ShadowRoot;
+}
+function Je(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = Q(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && !["inline", "contents"].includes(o);
+}
+function Ao(e) {
+  return ["table", "td", "th"].includes(ge(e));
+}
+function qt(e) {
+  const t = Kt(), n = Q(e);
+  return n.transform !== "none" || n.perspective !== "none" || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((r) => (n.willChange || "").includes(r)) || ["paint", "layout", "strict", "content"].some((r) => (n.contain || "").includes(r));
+}
+function Mo(e) {
+  let t = je(e);
+  for (; oe(t) && !ft(t); ) {
+    if (qt(t))
+      return t;
+    t = je(t);
+  }
+  return null;
+}
+function Kt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function ft(e) {
+  return ["html", "body", "#document"].includes(ge(e));
+}
+function Q(e) {
+  return q(e).getComputedStyle(e);
+}
+function dt(e) {
+  return ce(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.pageXOffset,
+    scrollTop: e.pageYOffset
+  };
+}
+function je(e) {
+  if (ge(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    En(e) && e.host || // Fallback.
+    le(e)
+  );
+  return En(t) ? t.host : t;
+}
+function or(e) {
+  const t = je(e);
+  return ft(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : oe(t) && Je(t) ? t : or(t);
+}
+function qe(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = or(e), i = o === ((r = e.ownerDocument) == null ? void 0 : r.body), s = q(o);
+  return i ? t.concat(s, s.visualViewport || [], Je(o) ? o : [], s.frameElement && n ? qe(s.frameElement) : []) : t.concat(o, qe(o, [], n));
+}
+function ir(e) {
+  const t = Q(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = oe(e), i = o ? e.offsetWidth : n, s = o ? e.offsetHeight : r, c = it(n) !== i || it(r) !== s;
+  return c && (n = i, r = s), {
+    width: n,
+    height: r,
+    $: c
+  };
+}
+function zt(e) {
+  return ce(e) ? e : e.contextElement;
+}
+function Me(e) {
+  const t = zt(e);
+  if (!oe(t))
+    return me(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = ir(t);
+  let s = (i ? it(n.width) : n.width) / r, c = (i ? it(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const Do = /* @__PURE__ */ me(0);
+function sr(e) {
+  const t = q(e);
+  return !Kt() || !t.visualViewport ? Do : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Fo(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== q(e) ? !1 : t;
+}
+function Ce(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = zt(e);
+  let s = me(1);
+  t && (r ? ce(r) && (s = Me(r)) : s = Me(e));
+  const c = Fo(i, n, r) ? sr(i) : me(0);
+  let l = (o.left + c.x) / s.x, u = (o.top + c.y) / s.y, f = o.width / s.x, h = o.height / s.y;
+  if (i) {
+    const d = q(i), m = r && ce(r) ? q(r) : r;
+    let y = d, E = y.frameElement;
+    for (; E && r && m !== y; ) {
+      const S = Me(E), w = E.getBoundingClientRect(), _ = Q(E), C = w.left + (E.clientLeft + parseFloat(_.paddingLeft)) * S.x, v = w.top + (E.clientTop + parseFloat(_.paddingTop)) * S.y;
+      l *= S.x, u *= S.y, f *= S.x, h *= S.y, l += C, u += v, y = q(E), E = y.frameElement;
+    }
+  }
+  return at({
+    width: f,
+    height: h,
+    x: l,
+    y: u
+  });
+}
+const Lo = [":popover-open", ":modal"];
+function ar(e) {
+  return Lo.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function jo(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const i = o === "fixed", s = le(r), c = t ? ar(t.floating) : !1;
+  if (r === s || c && i)
+    return n;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = me(1);
+  const f = me(0), h = oe(r);
+  if ((h || !h && !i) && ((ge(r) !== "body" || Je(s)) && (l = dt(r)), oe(r))) {
+    const d = Ce(r);
+    u = Me(r), f.x = d.x + r.clientLeft, f.y = d.y + r.clientTop;
+  }
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - l.scrollLeft * u.x + f.x,
+    y: n.y * u.y - l.scrollTop * u.y + f.y
+  };
+}
+function Bo(e) {
+  return Array.from(e.getClientRects());
+}
+function cr(e) {
+  return Ce(le(e)).left + dt(e).scrollLeft;
+}
+function $o(e) {
+  const t = le(e), n = dt(e), r = e.ownerDocument.body, o = _e(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = _e(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let s = -n.scrollLeft + cr(e);
+  const c = -n.scrollTop;
+  return Q(r).direction === "rtl" && (s += _e(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: s,
+    y: c
+  };
+}
+function Wo(e, t) {
+  const n = q(e), r = le(e), o = n.visualViewport;
+  let i = r.clientWidth, s = r.clientHeight, c = 0, l = 0;
+  if (o) {
+    i = o.width, s = o.height;
+    const u = Kt();
+    (!u || u && t === "fixed") && (c = o.offsetLeft, l = o.offsetTop);
+  }
+  return {
+    width: i,
+    height: s,
+    x: c,
+    y: l
+  };
+}
+function No(e, t) {
+  const n = Ce(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = oe(e) ? Me(e) : me(1), s = e.clientWidth * i.x, c = e.clientHeight * i.y, l = o * i.x, u = r * i.y;
+  return {
+    width: s,
+    height: c,
+    x: l,
+    y: u
+  };
+}
+function xn(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = Wo(e, n);
+  else if (t === "document")
+    r = $o(le(e));
+  else if (ce(t))
+    r = No(t, n);
+  else {
+    const o = sr(e);
+    r = B({}, t, {
+      x: t.x - o.x,
+      y: t.y - o.y
+    });
+  }
+  return at(r);
+}
+function lr(e, t) {
+  const n = je(e);
+  return n === t || !ce(n) || ft(n) ? !1 : Q(n).position === "fixed" || lr(n, t);
+}
+function Vo(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = qe(e, [], !1).filter((c) => ce(c) && ge(c) !== "body"), o = null;
+  const i = Q(e).position === "fixed";
+  let s = i ? je(e) : e;
+  for (; ce(s) && !ft(s); ) {
+    const c = Q(s), l = qt(s);
+    !l && c.position === "fixed" && (o = null), (i ? !l && !o : !l && c.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || Je(s) && !l && lr(e, s)) ? r = r.filter((f) => f !== s) : o = c, s = je(s);
+  }
+  return t.set(e, r), r;
+}
+function Uo(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const s = [...n === "clippingAncestors" ? Vo(t, this._c) : [].concat(n), r], c = s[0], l = s.reduce((u, f) => {
+    const h = xn(t, f, o);
+    return u.top = _e(h.top, u.top), u.right = Fe(h.right, u.right), u.bottom = Fe(h.bottom, u.bottom), u.left = _e(h.left, u.left), u;
+  }, xn(t, c, o));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+function Ho(e) {
+  const {
+    width: t,
+    height: n
+  } = ir(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Yo(e, t, n) {
+  const r = oe(t), o = le(t), i = n === "fixed", s = Ce(e, !0, i, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = me(0);
+  if (r || !r && !i)
+    if ((ge(t) !== "body" || Je(o)) && (c = dt(t)), r) {
+      const h = Ce(t, !0, i, t);
+      l.x = h.x + t.clientLeft, l.y = h.y + t.clientTop;
+    } else
+      o && (l.x = cr(o));
+  const u = s.left + c.scrollLeft - l.x, f = s.top + c.scrollTop - l.y;
+  return {
+    x: u,
+    y: f,
+    width: s.width,
+    height: s.height
+  };
+}
+function Sn(e, t) {
+  return !oe(e) || Q(e).position === "fixed" ? null : t ? t(e) : e.offsetParent;
+}
+function ur(e, t) {
+  const n = q(e);
+  if (!oe(e) || ar(e))
+    return n;
+  let r = Sn(e, t);
+  for (; r && Ao(r) && Q(r).position === "static"; )
+    r = Sn(r, t);
+  return r && (ge(r) === "html" || ge(r) === "body" && Q(r).position === "static" && !qt(r)) ? n : r || Mo(e) || n;
+}
+const qo = async function(t) {
+  const n = this.getOffsetParent || ur, r = this.getDimensions;
+  return {
+    reference: Yo(t.reference, await n(t.floating), t.strategy),
+    floating: B({
+      x: 0,
+      y: 0
+    }, await r(t.floating))
+  };
+};
+function Ko(e) {
+  return Q(e).direction === "rtl";
+}
+const zo = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: jo,
+  getDocumentElement: le,
+  getClippingRect: Uo,
+  getOffsetParent: ur,
+  getElementRects: qo,
+  getClientRects: Bo,
+  getDimensions: Ho,
+  getScale: Me,
+  isElement: ce,
+  isRTL: Ko
+};
+function Jo(e, t) {
+  let n = null, r;
+  const o = le(e);
+  function i() {
+    var c;
+    clearTimeout(r), (c = n) == null || c.disconnect(), n = null;
+  }
+  function s(c, l) {
+    c === void 0 && (c = !1), l === void 0 && (l = 1), i();
+    const {
+      left: u,
+      top: f,
+      width: h,
+      height: d
+    } = e.getBoundingClientRect();
+    if (c || t(), !h || !d)
+      return;
+    const m = rt(f), y = rt(o.clientWidth - (u + h)), E = rt(o.clientHeight - (f + d)), S = rt(u), _ = {
+      rootMargin: -m + "px " + -y + "px " + -E + "px " + -S + "px",
+      threshold: _e(0, Fe(1, l)) || 1
+    };
+    let C = !0;
+    function v(g) {
+      const T = g[0].intersectionRatio;
+      if (T !== l) {
+        if (!C)
+          return s();
+        T ? s(!1, T) : r = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 100);
+      }
+      C = !1;
+    }
+    try {
+      n = new IntersectionObserver(v, B({}, _, {
+        // Handle <iframe>s
+        root: o.ownerDocument
+      }));
+    } catch {
+      n = new IntersectionObserver(v, _);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function Go(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = r, u = zt(e), f = o || i ? [...u ? qe(u) : [], ...qe(t)] : [];
+  f.forEach((w) => {
+    o && w.addEventListener("scroll", n, {
+      passive: !0
+    }), i && w.addEventListener("resize", n);
+  });
+  const h = u && c ? Jo(u, n) : null;
+  let d = -1, m = null;
+  s && (m = new ResizeObserver((w) => {
+    let [_] = w;
+    _ && _.target === u && m && (m.unobserve(t), cancelAnimationFrame(d), d = requestAnimationFrame(() => {
+      var C;
+      (C = m) == null || C.observe(t);
+    })), n();
+  }), u && !l && m.observe(u), m.observe(t));
+  let y, E = l ? Ce(e) : null;
+  l && S();
+  function S() {
+    const w = Ce(e);
+    E && (w.x !== E.x || w.y !== E.y || w.width !== E.width || w.height !== E.height) && n(), E = w, y = requestAnimationFrame(S);
+  }
+  return n(), () => {
+    var w;
+    f.forEach((_) => {
+      o && _.removeEventListener("scroll", n), i && _.removeEventListener("resize", n);
+    }), h == null || h(), (w = m) == null || w.disconnect(), m = null, l && cancelAnimationFrame(y);
+  };
+}
+const Xo = Io, Zo = Po, Qo = Ro, ei = ko, ti = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = B({
+    platform: zo
+  }, n), i = B({}, o.platform, {
+    _c: r
+  });
+  return To(e, t, B({}, o, {
+    platform: i
+  }));
+};
+function ni(e) {
+  e.cleanup && e.cleanup();
+  const t = e._getResolvedAttachToOptions();
+  let n = t.element;
+  const r = ci(t, e), o = Qn(t);
+  return o && (n = document.body, e.shepherdElementComponent.getElement().classList.add("shepherd-centered")), e.cleanup = Go(n, e.el, () => {
+    var i;
+    if (!e.el) {
+      (i = e.cleanup) == null || i.call(e);
+      return;
+    }
+    ii(n, e, r, o);
+  }), e.target = t.element, r;
+}
+function ri(e, t) {
+  return {
+    floatingUIOptions: Vt(e.floatingUIOptions || {}, t.floatingUIOptions || {})
+  };
+}
+function oi(e) {
+  e.cleanup && e.cleanup(), e.cleanup = null;
+}
+function ii(e, t, n, r) {
+  return ti(e, t.el, n).then(si(t, r)).then((o) => new Promise((i) => {
+    setTimeout(() => i(o), 300);
+  })).then((o) => {
+    o != null && o.el && o.el.focus({ preventScroll: !0 });
+  });
+}
+function si(e, t) {
+  return ({ x: n, y: r, placement: o, middlewareData: i }) => (e.el && (t ? Object.assign(e.el.style, {
+    position: "fixed",
+    left: "50%",
+    top: "50%",
+    transform: "translate(-50%, -50%)"
+  }) : Object.assign(e.el.style, {
+    position: "absolute",
+    left: `${n}px`,
+    top: `${r}px`
+  }), e.el.dataset.popperPlacement = o, ai(e.el, i)), e);
+}
+function ai(e, t) {
+  const n = e.querySelector(".shepherd-arrow");
+  if (ze(n) && t.arrow) {
+    const { x: r, y: o } = t.arrow;
+    Object.assign(n.style, {
+      left: r != null ? `${r}px` : "",
+      top: o != null ? `${o}px` : ""
+    });
+  }
+}
+function ci(e, t) {
+  const n = {
+    strategy: "absolute"
+  };
+  n.middleware = [];
+  const r = li(t);
+  return Qn(e) || (n.middleware.push(
+    Zo(),
+    // Replicate PopperJS default behavior.
+    Xo({
+      limiter: ei(),
+      crossAxis: !0
+    })
+  ), r && n.middleware.push(Qo({ element: r })), n.placement = e.on), Vt(t.options.floatingUIOptions || {}, n);
+}
+function li(e) {
+  return e.options.arrow && e.el ? e.el.querySelector(".shepherd-arrow") : !1;
+}
+function K() {
+}
+function ui(e, t) {
+  for (const n in t)
+    e[n] = t[n];
+  return (
+    /** @type {T & S} */
+    e
+  );
+}
+function fr(e) {
+  return e();
+}
+function On() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function Ge(e) {
+  e.forEach(fr);
+}
+function Jt(e) {
+  return typeof e == "function";
+}
+function ue(e, t) {
+  return e != e ? t == t : e !== t || e && typeof e == "object" || typeof e == "function";
+}
+function fi(e) {
+  return Object.keys(e).length === 0;
+}
+function Be(e, t) {
+  e.appendChild(t);
+}
+function re(e, t, n) {
+  e.insertBefore(t, n || null);
+}
+function ee(e) {
+  e.parentNode && e.parentNode.removeChild(e);
+}
+function di(e, t) {
+  for (let n = 0; n < e.length; n += 1)
+    e[n] && e[n].d(t);
+}
+function ie(e) {
+  return document.createElement(e);
+}
+function Cn(e) {
+  return document.createElementNS("http://www.w3.org/2000/svg", e);
+}
+function dr(e) {
+  return document.createTextNode(e);
+}
+function ct() {
+  return dr(" ");
+}
+function hi() {
+  return dr("");
+}
+function ht(e, t, n, r) {
+  return e.addEventListener(t, n, r), () => e.removeEventListener(t, n, r);
+}
+function A(e, t, n) {
+  n == null ? e.removeAttribute(t) : e.getAttribute(t) !== n && e.setAttribute(t, n);
+}
+const pi = ["width", "height"];
+function Tn(e, t) {
+  const n = Object.getOwnPropertyDescriptors(e.__proto__);
+  for (const r in t)
+    t[r] == null ? e.removeAttribute(r) : r === "style" ? e.style.cssText = t[r] : r === "__value" ? e.value = e[r] = t[r] : n[r] && n[r].set && pi.indexOf(r) === -1 ? e[r] = t[r] : A(e, r, t[r]);
+}
+function mi(e) {
+  return Array.from(e.childNodes);
+}
+function Ie(e, t, n) {
+  e.classList.toggle(t, !!n);
+}
+let Ke;
+function He(e) {
+  Ke = e;
+}
+function hr() {
+  if (!Ke)
+    throw new Error("Function called outside component initialization");
+  return Ke;
+}
+function gi(e) {
+  hr().$$.on_mount.push(e);
+}
+function Gt(e) {
+  hr().$$.after_update.push(e);
+}
+const Ae = [], $e = [];
+let De = [];
+const Rn = [], bi = /* @__PURE__ */ Promise.resolve();
+let kt = !1;
+function yi() {
+  kt || (kt = !0, bi.then(pr));
+}
+function At(e) {
+  De.push(e);
+}
+const Ot = /* @__PURE__ */ new Set();
+let ke = 0;
+function pr() {
+  if (ke !== 0)
+    return;
+  const e = Ke;
+  do {
+    try {
+      for (; ke < Ae.length; ) {
+        const t = Ae[ke];
+        ke++, He(t), vi(t.$$);
+      }
+    } catch (t) {
+      throw Ae.length = 0, ke = 0, t;
+    }
+    for (He(null), Ae.length = 0, ke = 0; $e.length; )
+      $e.pop()();
+    for (let t = 0; t < De.length; t += 1) {
+      const n = De[t];
+      Ot.has(n) || (Ot.add(n), n());
+    }
+    De.length = 0;
+  } while (Ae.length);
+  for (; Rn.length; )
+    Rn.pop()();
+  kt = !1, Ot.clear(), He(e);
+}
+function vi(e) {
+  if (e.fragment !== null) {
+    e.update(), Ge(e.before_update);
+    const t = e.dirty;
+    e.dirty = [-1], e.fragment && e.fragment.p(e.ctx, t), e.after_update.forEach(At);
+  }
+}
+function wi(e) {
+  const t = [], n = [];
+  De.forEach((r) => e.indexOf(r) === -1 ? t.push(r) : n.push(r)), n.forEach((r) => r()), De = t;
+}
+const ot = /* @__PURE__ */ new Set();
+let we;
+function Ee() {
+  we = {
+    r: 0,
+    c: [],
+    p: we
+    // parent group
+  };
+}
+function xe() {
+  we.r || Ge(we.c), we = we.p;
+}
+function I(e, t) {
+  e && e.i && (ot.delete(e), e.i(t));
+}
+function L(e, t, n, r) {
+  if (e && e.o) {
+    if (ot.has(e))
+      return;
+    ot.add(e), we.c.push(() => {
+      ot.delete(e), r && (n && e.d(1), r());
+    }), e.o(t);
+  } else
+    r && r();
+}
+function Pn(e) {
+  return (e == null ? void 0 : e.length) !== void 0 ? e : Array.from(e);
+}
+function _i(e, t) {
+  const n = {}, r = {}, o = {
+    $$scope: 1
+  };
+  let i = e.length;
+  for (; i--; ) {
+    const s = e[i], c = t[i];
+    if (c) {
+      for (const l in s)
+        l in c || (r[l] = 1);
+      for (const l in c)
+        o[l] || (n[l] = c[l], o[l] = 1);
+      e[i] = c;
+    } else
+      for (const l in s)
+        o[l] = 1;
+  }
+  for (const s in r)
+    s in n || (n[s] = void 0);
+  return n;
+}
+function Te(e) {
+  e && e.c();
+}
+function ye(e, t, n) {
+  const {
+    fragment: r,
+    after_update: o
+  } = e.$$;
+  r && r.m(t, n), At(() => {
+    const i = e.$$.on_mount.map(fr).filter(Jt);
+    e.$$.on_destroy ? e.$$.on_destroy.push(...i) : Ge(i), e.$$.on_mount = [];
+  }), o.forEach(At);
+}
+function ve(e, t) {
+  const n = e.$$;
+  n.fragment !== null && (wi(n.after_update), Ge(n.on_destroy), n.fragment && n.fragment.d(t), n.on_destroy = n.fragment = null, n.ctx = []);
+}
+function Ei(e, t) {
+  e.$$.dirty[0] === -1 && (Ae.push(e), yi(), e.$$.dirty.fill(0)), e.$$.dirty[t / 31 | 0] |= 1 << t % 31;
+}
+function fe(e, t, n, r, o, i, s = null, c = [-1]) {
+  const l = Ke;
+  He(e);
+  const u = e.$$ = {
+    fragment: null,
+    ctx: [],
+    // state
+    props: i,
+    update: K,
+    not_equal: o,
+    bound: On(),
+    // lifecycle
+    on_mount: [],
+    on_destroy: [],
+    on_disconnect: [],
+    before_update: [],
+    after_update: [],
+    context: new Map(t.context || (l ? l.$$.context : [])),
+    // everything else
+    callbacks: On(),
+    dirty: c,
+    skip_bound: !1,
+    root: t.target || l.$$.root
+  };
+  s && s(u.root);
+  let f = !1;
+  if (u.ctx = n ? n(e, t.props || {}, (h, d, ...m) => {
+    const y = m.length ? m[0] : d;
+    return u.ctx && o(u.ctx[h], u.ctx[h] = y) && (!u.skip_bound && u.bound[h] && u.bound[h](y), f && Ei(e, h)), d;
+  }) : [], u.update(), f = !0, Ge(u.before_update), u.fragment = r ? r(u.ctx) : !1, t.target) {
+    if (t.hydrate) {
+      const h = mi(t.target);
+      u.fragment && u.fragment.l(h), h.forEach(ee);
+    } else
+      u.fragment && u.fragment.c();
+    t.intro && I(e.$$.fragment), ye(e, t.target, t.anchor), pr();
+  }
+  He(l);
+}
+class de {
+  constructor() {
+    this.$$ = void 0, this.$$set = void 0;
+  }
+  /** @returns {void} */
+  $destroy() {
+    ve(this, 1), this.$destroy = K;
+  }
+  /**
+   * @template {Extract<keyof Events, string>} K
+   * @param {K} type
+   * @param {((e: Events[K]) => void) | null | undefined} callback
+   * @returns {() => void}
+   */
+  $on(t, n) {
+    if (!Jt(n))
+      return K;
+    const r = this.$$.callbacks[t] || (this.$$.callbacks[t] = []);
+    return r.push(n), () => {
+      const o = r.indexOf(n);
+      o !== -1 && r.splice(o, 1);
+    };
+  }
+  /**
+   * @param {Partial<Props>} props
+   * @returns {void}
+   */
+  $set(t) {
+    this.$$set && !fi(t) && (this.$$.skip_bound = !0, this.$$set(t), this.$$.skip_bound = !1);
+  }
+}
+const xi = "4";
+typeof window < "u" && (window.__svelte || (window.__svelte = {
+  v: /* @__PURE__ */ new Set()
+})).v.add(xi);
+function Si(e) {
+  let t, n, r, o, i;
+  return {
+    c() {
+      t = ie("button"), A(t, "aria-label", n = /*label*/
+      e[3] ? (
+        /*label*/
+        e[3]
+      ) : null), A(t, "class", r = `${/*classes*/
+      e[1] || ""} shepherd-button ${/*secondary*/
+      e[4] ? "shepherd-button-secondary" : ""}`), t.disabled = /*disabled*/
+      e[2], A(t, "tabindex", "0");
+    },
+    m(s, c) {
+      re(s, t, c), t.innerHTML = /*text*/
+      e[5], o || (i = ht(t, "click", function() {
+        Jt(
+          /*action*/
+          e[0]
+        ) && e[0].apply(this, arguments);
+      }), o = !0);
+    },
+    p(s, [c]) {
+      e = s, c & /*text*/
+      32 && (t.innerHTML = /*text*/
+      e[5]), c & /*label*/
+      8 && n !== (n = /*label*/
+      e[3] ? (
+        /*label*/
+        e[3]
+      ) : null) && A(t, "aria-label", n), c & /*classes, secondary*/
+      18 && r !== (r = `${/*classes*/
+      e[1] || ""} shepherd-button ${/*secondary*/
+      e[4] ? "shepherd-button-secondary" : ""}`) && A(t, "class", r), c & /*disabled*/
+      4 && (t.disabled = /*disabled*/
+      e[2]);
+    },
+    i: K,
+    o: K,
+    d(s) {
+      s && ee(t), o = !1, i();
+    }
+  };
+}
+function Oi(e, t, n) {
+  let {
+    config: r,
+    step: o
+  } = t, i, s, c, l, u, f;
+  function h(d) {
+    return pe(d) ? d = d.call(o) : d;
+  }
+  return e.$$set = (d) => {
+    "config" in d && n(6, r = d.config), "step" in d && n(7, o = d.step);
+  }, e.$$.update = () => {
+    e.$$.dirty & /*config, step*/
+    192 && (n(0, i = r.action ? r.action.bind(o.tour) : null), n(1, s = r.classes), n(2, c = r.disabled ? h(r.disabled) : !1), n(3, l = r.label ? h(r.label) : null), n(4, u = r.secondary), n(5, f = r.text ? h(r.text) : null));
+  }, [i, s, c, l, u, f, r, o];
+}
+class Ci extends de {
+  constructor(t) {
+    super(), fe(this, t, Oi, Si, ue, {
+      config: 6,
+      step: 7
+    });
+  }
+}
+function In(e, t, n) {
+  const r = e.slice();
+  return r[2] = t[n], r;
+}
+function kn(e) {
+  let t, n, r = Pn(
+    /*buttons*/
+    e[1]
+  ), o = [];
+  for (let s = 0; s < r.length; s += 1)
+    o[s] = An(In(e, r, s));
+  const i = (s) => L(o[s], 1, 1, () => {
+    o[s] = null;
+  });
+  return {
+    c() {
+      for (let s = 0; s < o.length; s += 1)
+        o[s].c();
+      t = hi();
+    },
+    m(s, c) {
+      for (let l = 0; l < o.length; l += 1)
+        o[l] && o[l].m(s, c);
+      re(s, t, c), n = !0;
+    },
+    p(s, c) {
+      if (c & /*buttons, step*/
+      3) {
+        r = Pn(
+          /*buttons*/
+          s[1]
+        );
+        let l;
+        for (l = 0; l < r.length; l += 1) {
+          const u = In(s, r, l);
+          o[l] ? (o[l].p(u, c), I(o[l], 1)) : (o[l] = An(u), o[l].c(), I(o[l], 1), o[l].m(t.parentNode, t));
+        }
+        for (Ee(), l = r.length; l < o.length; l += 1)
+          i(l);
+        xe();
+      }
+    },
+    i(s) {
+      if (!n) {
+        for (let c = 0; c < r.length; c += 1)
+          I(o[c]);
+        n = !0;
+      }
+    },
+    o(s) {
+      o = o.filter(Boolean);
+      for (let c = 0; c < o.length; c += 1)
+        L(o[c]);
+      n = !1;
+    },
+    d(s) {
+      s && ee(t), di(o, s);
+    }
+  };
+}
+function An(e) {
+  let t, n;
+  return t = new Ci({
+    props: {
+      config: (
+        /*config*/
+        e[2]
+      ),
+      step: (
+        /*step*/
+        e[0]
+      )
+    }
+  }), {
+    c() {
+      Te(t.$$.fragment);
+    },
+    m(r, o) {
+      ye(t, r, o), n = !0;
+    },
+    p(r, o) {
+      const i = {};
+      o & /*buttons*/
+      2 && (i.config = /*config*/
+      r[2]), o & /*step*/
+      1 && (i.step = /*step*/
+      r[0]), t.$set(i);
+    },
+    i(r) {
+      n || (I(t.$$.fragment, r), n = !0);
+    },
+    o(r) {
+      L(t.$$.fragment, r), n = !1;
+    },
+    d(r) {
+      ve(t, r);
+    }
+  };
+}
+function Ti(e) {
+  let t, n, r = (
+    /*buttons*/
+    e[1] && kn(e)
+  );
+  return {
+    c() {
+      t = ie("footer"), r && r.c(), A(t, "class", "shepherd-footer");
+    },
+    m(o, i) {
+      re(o, t, i), r && r.m(t, null), n = !0;
+    },
+    p(o, [i]) {
+      /*buttons*/
+      o[1] ? r ? (r.p(o, i), i & /*buttons*/
+      2 && I(r, 1)) : (r = kn(o), r.c(), I(r, 1), r.m(t, null)) : r && (Ee(), L(r, 1, 1, () => {
+        r = null;
+      }), xe());
+    },
+    i(o) {
+      n || (I(r), n = !0);
+    },
+    o(o) {
+      L(r), n = !1;
+    },
+    d(o) {
+      o && ee(t), r && r.d();
+    }
+  };
+}
+function Ri(e, t, n) {
+  let r, {
+    step: o
+  } = t;
+  return e.$$set = (i) => {
+    "step" in i && n(0, o = i.step);
+  }, e.$$.update = () => {
+    e.$$.dirty & /*step*/
+    1 && n(1, r = o.options.buttons);
+  }, [o, r];
+}
+class Pi extends de {
+  constructor(t) {
+    super(), fe(this, t, Ri, Ti, ue, {
+      step: 0
+    });
+  }
+}
+function Ii(e) {
+  let t, n, r, o, i;
+  return {
+    c() {
+      t = ie("button"), n = ie("span"), n.textContent = "×", A(n, "aria-hidden", "true"), A(t, "aria-label", r = /*cancelIcon*/
+      e[0].label ? (
+        /*cancelIcon*/
+        e[0].label
+      ) : "Close Tour"), A(t, "class", "shepherd-cancel-icon"), A(t, "type", "button");
+    },
+    m(s, c) {
+      re(s, t, c), Be(t, n), o || (i = ht(
+        t,
+        "click",
+        /*handleCancelClick*/
+        e[1]
+      ), o = !0);
+    },
+    p(s, [c]) {
+      c & /*cancelIcon*/
+      1 && r !== (r = /*cancelIcon*/
+      s[0].label ? (
+        /*cancelIcon*/
+        s[0].label
+      ) : "Close Tour") && A(t, "aria-label", r);
+    },
+    i: K,
+    o: K,
+    d(s) {
+      s && ee(t), o = !1, i();
+    }
+  };
+}
+function ki(e, t, n) {
+  let {
+    cancelIcon: r,
+    step: o
+  } = t;
+  const i = (s) => {
+    s.preventDefault(), o.cancel();
+  };
+  return e.$$set = (s) => {
+    "cancelIcon" in s && n(0, r = s.cancelIcon), "step" in s && n(2, o = s.step);
+  }, [r, i, o];
+}
+class Ai extends de {
+  constructor(t) {
+    super(), fe(this, t, ki, Ii, ue, {
+      cancelIcon: 0,
+      step: 2
+    });
+  }
+}
+function Mi(e) {
+  let t;
+  return {
+    c() {
+      t = ie("h3"), A(
+        t,
+        "id",
+        /*labelId*/
+        e[1]
+      ), A(t, "class", "shepherd-title");
+    },
+    m(n, r) {
+      re(n, t, r), e[3](t);
+    },
+    p(n, [r]) {
+      r & /*labelId*/
+      2 && A(
+        t,
+        "id",
+        /*labelId*/
+        n[1]
+      );
+    },
+    i: K,
+    o: K,
+    d(n) {
+      n && ee(t), e[3](null);
+    }
+  };
+}
+function Di(e, t, n) {
+  let {
+    labelId: r,
+    element: o,
+    title: i
+  } = t;
+  Gt(() => {
+    pe(i) && n(2, i = i()), n(0, o.innerHTML = i, o);
+  });
+  function s(c) {
+    $e[c ? "unshift" : "push"](() => {
+      o = c, n(0, o);
+    });
+  }
+  return e.$$set = (c) => {
+    "labelId" in c && n(1, r = c.labelId), "element" in c && n(0, o = c.element), "title" in c && n(2, i = c.title);
+  }, [o, r, i, s];
+}
+class Fi extends de {
+  constructor(t) {
+    super(), fe(this, t, Di, Mi, ue, {
+      labelId: 1,
+      element: 0,
+      title: 2
+    });
+  }
+}
+function Mn(e) {
+  let t, n;
+  return t = new Fi({
+    props: {
+      labelId: (
+        /*labelId*/
+        e[0]
+      ),
+      title: (
+        /*title*/
+        e[2]
+      )
+    }
+  }), {
+    c() {
+      Te(t.$$.fragment);
+    },
+    m(r, o) {
+      ye(t, r, o), n = !0;
+    },
+    p(r, o) {
+      const i = {};
+      o & /*labelId*/
+      1 && (i.labelId = /*labelId*/
+      r[0]), o & /*title*/
+      4 && (i.title = /*title*/
+      r[2]), t.$set(i);
+    },
+    i(r) {
+      n || (I(t.$$.fragment, r), n = !0);
+    },
+    o(r) {
+      L(t.$$.fragment, r), n = !1;
+    },
+    d(r) {
+      ve(t, r);
+    }
+  };
+}
+function Dn(e) {
+  let t, n;
+  return t = new Ai({
+    props: {
+      cancelIcon: (
+        /*cancelIcon*/
+        e[3]
+      ),
+      step: (
+        /*step*/
+        e[1]
+      )
+    }
+  }), {
+    c() {
+      Te(t.$$.fragment);
+    },
+    m(r, o) {
+      ye(t, r, o), n = !0;
+    },
+    p(r, o) {
+      const i = {};
+      o & /*cancelIcon*/
+      8 && (i.cancelIcon = /*cancelIcon*/
+      r[3]), o & /*step*/
+      2 && (i.step = /*step*/
+      r[1]), t.$set(i);
+    },
+    i(r) {
+      n || (I(t.$$.fragment, r), n = !0);
+    },
+    o(r) {
+      L(t.$$.fragment, r), n = !1;
+    },
+    d(r) {
+      ve(t, r);
+    }
+  };
+}
+function Li(e) {
+  let t, n, r, o = (
+    /*title*/
+    e[2] && Mn(e)
+  ), i = (
+    /*cancelIcon*/
+    e[3] && /*cancelIcon*/
+    e[3].enabled && Dn(e)
+  );
+  return {
+    c() {
+      t = ie("header"), o && o.c(), n = ct(), i && i.c(), A(t, "class", "shepherd-header");
+    },
+    m(s, c) {
+      re(s, t, c), o && o.m(t, null), Be(t, n), i && i.m(t, null), r = !0;
+    },
+    p(s, [c]) {
+      /*title*/
+      s[2] ? o ? (o.p(s, c), c & /*title*/
+      4 && I(o, 1)) : (o = Mn(s), o.c(), I(o, 1), o.m(t, n)) : o && (Ee(), L(o, 1, 1, () => {
+        o = null;
+      }), xe()), /*cancelIcon*/
+      s[3] && /*cancelIcon*/
+      s[3].enabled ? i ? (i.p(s, c), c & /*cancelIcon*/
+      8 && I(i, 1)) : (i = Dn(s), i.c(), I(i, 1), i.m(t, null)) : i && (Ee(), L(i, 1, 1, () => {
+        i = null;
+      }), xe());
+    },
+    i(s) {
+      r || (I(o), I(i), r = !0);
+    },
+    o(s) {
+      L(o), L(i), r = !1;
+    },
+    d(s) {
+      s && ee(t), o && o.d(), i && i.d();
+    }
+  };
+}
+function ji(e, t, n) {
+  let {
+    labelId: r,
+    step: o
+  } = t, i, s;
+  return e.$$set = (c) => {
+    "labelId" in c && n(0, r = c.labelId), "step" in c && n(1, o = c.step);
+  }, e.$$.update = () => {
+    e.$$.dirty & /*step*/
+    2 && (n(2, i = o.options.title), n(3, s = o.options.cancelIcon));
+  }, [r, o, i, s];
+}
+class Bi extends de {
+  constructor(t) {
+    super(), fe(this, t, ji, Li, ue, {
+      labelId: 0,
+      step: 1
+    });
+  }
+}
+function $i(e) {
+  let t;
+  return {
+    c() {
+      t = ie("div"), A(t, "class", "shepherd-text"), A(
+        t,
+        "id",
+        /*descriptionId*/
+        e[1]
+      );
+    },
+    m(n, r) {
+      re(n, t, r), e[3](t);
+    },
+    p(n, [r]) {
+      r & /*descriptionId*/
+      2 && A(
+        t,
+        "id",
+        /*descriptionId*/
+        n[1]
+      );
+    },
+    i: K,
+    o: K,
+    d(n) {
+      n && ee(t), e[3](null);
+    }
+  };
+}
+function Wi(e, t, n) {
+  let {
+    descriptionId: r,
+    element: o,
+    step: i
+  } = t;
+  Gt(() => {
+    let {
+      text: c
+    } = i.options;
+    pe(c) && (c = c.call(i)), ze(c) ? o.appendChild(c) : n(0, o.innerHTML = c, o);
+  });
+  function s(c) {
+    $e[c ? "unshift" : "push"](() => {
+      o = c, n(0, o);
+    });
+  }
+  return e.$$set = (c) => {
+    "descriptionId" in c && n(1, r = c.descriptionId), "element" in c && n(0, o = c.element), "step" in c && n(2, i = c.step);
+  }, [o, r, i, s];
+}
+class Ni extends de {
+  constructor(t) {
+    super(), fe(this, t, Wi, $i, ue, {
+      descriptionId: 1,
+      element: 0,
+      step: 2
+    });
+  }
+}
+function Fn(e) {
+  let t, n;
+  return t = new Bi({
+    props: {
+      labelId: (
+        /*labelId*/
+        e[1]
+      ),
+      step: (
+        /*step*/
+        e[2]
+      )
+    }
+  }), {
+    c() {
+      Te(t.$$.fragment);
+    },
+    m(r, o) {
+      ye(t, r, o), n = !0;
+    },
+    p(r, o) {
+      const i = {};
+      o & /*labelId*/
+      2 && (i.labelId = /*labelId*/
+      r[1]), o & /*step*/
+      4 && (i.step = /*step*/
+      r[2]), t.$set(i);
+    },
+    i(r) {
+      n || (I(t.$$.fragment, r), n = !0);
+    },
+    o(r) {
+      L(t.$$.fragment, r), n = !1;
+    },
+    d(r) {
+      ve(t, r);
+    }
+  };
+}
+function Ln(e) {
+  let t, n;
+  return t = new Ni({
+    props: {
+      descriptionId: (
+        /*descriptionId*/
+        e[0]
+      ),
+      step: (
+        /*step*/
+        e[2]
+      )
+    }
+  }), {
+    c() {
+      Te(t.$$.fragment);
+    },
+    m(r, o) {
+      ye(t, r, o), n = !0;
+    },
+    p(r, o) {
+      const i = {};
+      o & /*descriptionId*/
+      1 && (i.descriptionId = /*descriptionId*/
+      r[0]), o & /*step*/
+      4 && (i.step = /*step*/
+      r[2]), t.$set(i);
+    },
+    i(r) {
+      n || (I(t.$$.fragment, r), n = !0);
+    },
+    o(r) {
+      L(t.$$.fragment, r), n = !1;
+    },
+    d(r) {
+      ve(t, r);
+    }
+  };
+}
+function jn(e) {
+  let t, n;
+  return t = new Pi({
+    props: {
+      step: (
+        /*step*/
+        e[2]
+      )
+    }
+  }), {
+    c() {
+      Te(t.$$.fragment);
+    },
+    m(r, o) {
+      ye(t, r, o), n = !0;
+    },
+    p(r, o) {
+      const i = {};
+      o & /*step*/
+      4 && (i.step = /*step*/
+      r[2]), t.$set(i);
+    },
+    i(r) {
+      n || (I(t.$$.fragment, r), n = !0);
+    },
+    o(r) {
+      L(t.$$.fragment, r), n = !1;
+    },
+    d(r) {
+      ve(t, r);
+    }
+  };
+}
+function Vi(e) {
+  let t, n = !V(
+    /*step*/
+    e[2].options.title
+  ) || /*step*/
+  e[2].options.cancelIcon && /*step*/
+  e[2].options.cancelIcon.enabled, r, o = !V(
+    /*step*/
+    e[2].options.text
+  ), i, s = Array.isArray(
+    /*step*/
+    e[2].options.buttons
+  ) && /*step*/
+  e[2].options.buttons.length, c, l = n && Fn(e), u = o && Ln(e), f = s && jn(e);
+  return {
+    c() {
+      t = ie("div"), l && l.c(), r = ct(), u && u.c(), i = ct(), f && f.c(), A(t, "class", "shepherd-content");
+    },
+    m(h, d) {
+      re(h, t, d), l && l.m(t, null), Be(t, r), u && u.m(t, null), Be(t, i), f && f.m(t, null), c = !0;
+    },
+    p(h, [d]) {
+      d & /*step*/
+      4 && (n = !V(
+        /*step*/
+        h[2].options.title
+      ) || /*step*/
+      h[2].options.cancelIcon && /*step*/
+      h[2].options.cancelIcon.enabled), n ? l ? (l.p(h, d), d & /*step*/
+      4 && I(l, 1)) : (l = Fn(h), l.c(), I(l, 1), l.m(t, r)) : l && (Ee(), L(l, 1, 1, () => {
+        l = null;
+      }), xe()), d & /*step*/
+      4 && (o = !V(
+        /*step*/
+        h[2].options.text
+      )), o ? u ? (u.p(h, d), d & /*step*/
+      4 && I(u, 1)) : (u = Ln(h), u.c(), I(u, 1), u.m(t, i)) : u && (Ee(), L(u, 1, 1, () => {
+        u = null;
+      }), xe()), d & /*step*/
+      4 && (s = Array.isArray(
+        /*step*/
+        h[2].options.buttons
+      ) && /*step*/
+      h[2].options.buttons.length), s ? f ? (f.p(h, d), d & /*step*/
+      4 && I(f, 1)) : (f = jn(h), f.c(), I(f, 1), f.m(t, null)) : f && (Ee(), L(f, 1, 1, () => {
+        f = null;
+      }), xe());
+    },
+    i(h) {
+      c || (I(l), I(u), I(f), c = !0);
+    },
+    o(h) {
+      L(l), L(u), L(f), c = !1;
+    },
+    d(h) {
+      h && ee(t), l && l.d(), u && u.d(), f && f.d();
+    }
+  };
+}
+function Ui(e, t, n) {
+  let {
+    descriptionId: r,
+    labelId: o,
+    step: i
+  } = t;
+  return e.$$set = (s) => {
+    "descriptionId" in s && n(0, r = s.descriptionId), "labelId" in s && n(1, o = s.labelId), "step" in s && n(2, i = s.step);
+  }, [r, o, i];
+}
+class Hi extends de {
+  constructor(t) {
+    super(), fe(this, t, Ui, Vi, ue, {
+      descriptionId: 0,
+      labelId: 1,
+      step: 2
+    });
+  }
+}
+function Bn(e) {
+  let t;
+  return {
+    c() {
+      t = ie("div"), A(t, "class", "shepherd-arrow"), A(t, "data-popper-arrow", "");
+    },
+    m(n, r) {
+      re(n, t, r);
+    },
+    d(n) {
+      n && ee(t);
+    }
+  };
+}
+function Yi(e) {
+  let t, n, r, o, i, s, c, l, u = (
+    /*step*/
+    e[4].options.arrow && /*step*/
+    e[4].options.attachTo && /*step*/
+    e[4].options.attachTo.element && /*step*/
+    e[4].options.attachTo.on && Bn()
+  );
+  r = new Hi({
+    props: {
+      descriptionId: (
+        /*descriptionId*/
+        e[2]
+      ),
+      labelId: (
+        /*labelId*/
+        e[3]
+      ),
+      step: (
+        /*step*/
+        e[4]
+      )
+    }
+  });
+  let f = [
+    {
+      "aria-describedby": o = V(
+        /*step*/
+        e[4].options.text
+      ) ? null : (
+        /*descriptionId*/
+        e[2]
+      )
+    },
+    {
+      "aria-labelledby": i = /*step*/
+      e[4].options.title ? (
+        /*labelId*/
+        e[3]
+      ) : null
+    },
+    /*dataStepId*/
+    e[1],
+    {
+      role: "dialog"
+    },
+    {
+      tabindex: "0"
+    }
+  ], h = {};
+  for (let d = 0; d < f.length; d += 1)
+    h = ui(h, f[d]);
+  return {
+    c() {
+      t = ie("div"), u && u.c(), n = ct(), Te(r.$$.fragment), Tn(t, h), Ie(
+        t,
+        "shepherd-has-cancel-icon",
+        /*hasCancelIcon*/
+        e[5]
+      ), Ie(
+        t,
+        "shepherd-has-title",
+        /*hasTitle*/
+        e[6]
+      ), Ie(t, "shepherd-element", !0);
+    },
+    m(d, m) {
+      re(d, t, m), u && u.m(t, null), Be(t, n), ye(r, t, null), e[13](t), s = !0, c || (l = ht(
+        t,
+        "keydown",
+        /*handleKeyDown*/
+        e[7]
+      ), c = !0);
+    },
+    p(d, [m]) {
+      /*step*/
+      d[4].options.arrow && /*step*/
+      d[4].options.attachTo && /*step*/
+      d[4].options.attachTo.element && /*step*/
+      d[4].options.attachTo.on ? u || (u = Bn(), u.c(), u.m(t, n)) : u && (u.d(1), u = null);
+      const y = {};
+      m & /*descriptionId*/
+      4 && (y.descriptionId = /*descriptionId*/
+      d[2]), m & /*labelId*/
+      8 && (y.labelId = /*labelId*/
+      d[3]), m & /*step*/
+      16 && (y.step = /*step*/
+      d[4]), r.$set(y), Tn(t, h = _i(f, [(!s || m & /*step, descriptionId*/
+      20 && o !== (o = V(
+        /*step*/
+        d[4].options.text
+      ) ? null : (
+        /*descriptionId*/
+        d[2]
+      ))) && {
+        "aria-describedby": o
+      }, (!s || m & /*step, labelId*/
+      24 && i !== (i = /*step*/
+      d[4].options.title ? (
+        /*labelId*/
+        d[3]
+      ) : null)) && {
+        "aria-labelledby": i
+      }, m & /*dataStepId*/
+      2 && /*dataStepId*/
+      d[1], {
+        role: "dialog"
+      }, {
+        tabindex: "0"
+      }])), Ie(
+        t,
+        "shepherd-has-cancel-icon",
+        /*hasCancelIcon*/
+        d[5]
+      ), Ie(
+        t,
+        "shepherd-has-title",
+        /*hasTitle*/
+        d[6]
+      ), Ie(t, "shepherd-element", !0);
+    },
+    i(d) {
+      s || (I(r.$$.fragment, d), s = !0);
+    },
+    o(d) {
+      L(r.$$.fragment, d), s = !1;
+    },
+    d(d) {
+      d && ee(t), u && u.d(), ve(r), e[13](null), c = !1, l();
+    }
+  };
+}
+const qi = 9, Ki = 27, zi = 37, Ji = 39;
+function $n(e) {
+  return e.split(" ").filter((t) => !!t.length);
+}
+function Gi(e, t, n) {
+  let {
+    classPrefix: r,
+    element: o,
+    descriptionId: i,
+    firstFocusableElement: s,
+    focusableElements: c,
+    labelId: l,
+    lastFocusableElement: u,
+    step: f,
+    dataStepId: h
+  } = t, d, m, y;
+  const E = () => o;
+  gi(() => {
+    n(1, h = {
+      [`data-${r}shepherd-step-id`]: f.id
+    }), n(9, c = o.querySelectorAll('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), [tabindex="0"]')), n(8, s = c[0]), n(10, u = c[c.length - 1]);
+  }), Gt(() => {
+    y !== f.options.classes && S();
+  });
+  function S() {
+    w(y), y = f.options.classes, _(y);
+  }
+  function w(g) {
+    if (Ye(g)) {
+      const T = $n(g);
+      T.length && o.classList.remove(...T);
+    }
+  }
+  function _(g) {
+    if (Ye(g)) {
+      const T = $n(g);
+      T.length && o.classList.add(...T);
+    }
+  }
+  const C = (g) => {
+    const {
+      tour: T
+    } = f;
+    switch (g.keyCode) {
+      case qi:
+        if (c.length === 0) {
+          g.preventDefault();
+          break;
+        }
+        g.shiftKey ? (document.activeElement === s || document.activeElement.classList.contains("shepherd-element")) && (g.preventDefault(), u.focus()) : document.activeElement === u && (g.preventDefault(), s.focus());
+        break;
+      case Ki:
+        T.options.exitOnEsc && (g.preventDefault(), g.stopPropagation(), f.cancel());
+        break;
+      case zi:
+        T.options.keyboardNavigation && (g.preventDefault(), g.stopPropagation(), T.back());
+        break;
+      case Ji:
+        T.options.keyboardNavigation && (g.preventDefault(), g.stopPropagation(), T.next());
+        break;
+    }
+  };
+  function v(g) {
+    $e[g ? "unshift" : "push"](() => {
+      o = g, n(0, o);
+    });
+  }
+  return e.$$set = (g) => {
+    "classPrefix" in g && n(11, r = g.classPrefix), "element" in g && n(0, o = g.element), "descriptionId" in g && n(2, i = g.descriptionId), "firstFocusableElement" in g && n(8, s = g.firstFocusableElement), "focusableElements" in g && n(9, c = g.focusableElements), "labelId" in g && n(3, l = g.labelId), "lastFocusableElement" in g && n(10, u = g.lastFocusableElement), "step" in g && n(4, f = g.step), "dataStepId" in g && n(1, h = g.dataStepId);
+  }, e.$$.update = () => {
+    e.$$.dirty & /*step*/
+    16 && (n(5, d = f.options && f.options.cancelIcon && f.options.cancelIcon.enabled), n(6, m = f.options && f.options.title));
+  }, [o, h, i, l, f, d, m, C, s, c, u, r, E, v];
+}
+class Xi extends de {
+  constructor(t) {
+    super(), fe(this, t, Gi, Yi, ue, {
+      classPrefix: 11,
+      element: 0,
+      descriptionId: 2,
+      firstFocusableElement: 8,
+      focusableElements: 9,
+      labelId: 3,
+      lastFocusableElement: 10,
+      step: 4,
+      dataStepId: 1,
+      getElement: 12
+    });
+  }
+  get getElement() {
+    return this.$$.ctx[12];
+  }
+}
+class Mt extends Nt {
+  constructor(t, n = {}) {
+    return super(), this.tour = t, this.classPrefix = this.tour.options ? Zn(this.tour.options.classPrefix) : "", this.styles = t.styles, this._resolvedAttachTo = null, Xn(this), this._setOptions(n), this;
+  }
+  /**
+   * Cancel the tour
+   * Triggers the `cancel` event
+   */
+  cancel() {
+    this.tour.cancel(), this.trigger("cancel");
+  }
+  /**
+   * Complete the tour
+   * Triggers the `complete` event
+   */
+  complete() {
+    this.tour.complete(), this.trigger("complete");
+  }
+  /**
+   * Remove the step, delete the step's element, and destroy the FloatingUI instance for the step.
+   * Triggers `destroy` event
+   */
+  destroy() {
+    oi(this), ze(this.el) && (this.el.remove(), this.el = null), this._updateStepTargetOnHide(), this.trigger("destroy");
+  }
+  /**
+   * Returns the tour for the step
+   * @return The tour instance
+   */
+  getTour() {
+    return this.tour;
+  }
+  /**
+   * Hide the step
+   */
+  hide() {
+    this.tour.modal.hide(), this.trigger("before-hide"), this.el && (this.el.hidden = !0), this._updateStepTargetOnHide(), this.trigger("hide");
+  }
+  /**
+   * Resolves attachTo options.
+   * @returns {{}|{element, on}}
+   */
+  _resolveAttachToOptions() {
+    return this._resolvedAttachTo = bo(this), this._resolvedAttachTo;
+  }
+  /**
+   * A selector for resolved attachTo options.
+   * @returns {{}|{element, on}}
+   * @private
+   */
+  _getResolvedAttachToOptions() {
+    return this._resolvedAttachTo === null ? this._resolveAttachToOptions() : this._resolvedAttachTo;
+  }
+  /**
+   * Check if the step is open and visible
+   * @return True if the step is open and visible
+   */
+  isOpen() {
+    return !!(this.el && !this.el.hidden);
+  }
+  /**
+   * Wraps `_show` and ensures `beforeShowPromise` resolves before calling show
+   */
+  show() {
+    return pe(this.options.beforeShowPromise) ? Promise.resolve(this.options.beforeShowPromise()).then(() => this._show()) : Promise.resolve(this._show());
+  }
+  /**
+   * Updates the options of the step.
+   *
+   * @param {StepOptions} options The options for the step
+   */
+  updateStepOptions(t) {
+    Object.assign(this.options, t), this.shepherdElementComponent && this.shepherdElementComponent.$set({ step: this });
+  }
+  /**
+   * Returns the element for the step
+   * @return {HTMLElement|null|undefined} The element instance. undefined if it has never been shown, null if it has been destroyed
+   */
+  getElement() {
+    return this.el;
+  }
+  /**
+   * Returns the target for the step
+   * @return {HTMLElement|null|undefined} The element instance. undefined if it has never been shown, null if query string has not been found
+   */
+  getTarget() {
+    return this.target;
+  }
+  /**
+   * Creates Shepherd element for step based on options
+   *
+   * @return {HTMLElement} The DOM element for the step tooltip
+   * @private
+   */
+  _createTooltipContent() {
+    const t = `${this.id}-description`, n = `${this.id}-label`;
+    return this.shepherdElementComponent = new Xi({
+      target: this.tour.options.stepsContainer || document.body,
+      props: {
+        classPrefix: this.classPrefix,
+        descriptionId: t,
+        labelId: n,
+        step: this,
+        // @ts-expect-error TODO: investigate where styles comes from
+        styles: this.styles
+      }
+    }), this.shepherdElementComponent.getElement();
+  }
+  /**
+   * If a custom scrollToHandler is defined, call that, otherwise do the generic
+   * scrollIntoView call.
+   *
+   * @param {boolean | ScrollIntoViewOptions} scrollToOptions - If true, uses the default `scrollIntoView`,
+   * if an object, passes that object as the params to `scrollIntoView` i.e. `{ behavior: 'smooth', block: 'center' }`
+   * @private
+   */
+  _scrollTo(t) {
+    const { element: n } = this._getResolvedAttachToOptions();
+    pe(this.options.scrollToHandler) ? this.options.scrollToHandler(n) : Gr(n) && typeof n.scrollIntoView == "function" && n.scrollIntoView(t);
+  }
+  /**
+   * _getClassOptions gets all possible classes for the step
+   * @param {StepOptions} stepOptions The step specific options
+   * @returns {string} unique string from array of classes
+   */
+  _getClassOptions(t) {
+    const n = this.tour && this.tour.options && this.tour.options.defaultStepOptions, r = t.classes ? t.classes : "", o = n && n.classes ? n.classes : "", i = [
+      ...r.split(" "),
+      ...o.split(" ")
+    ], s = new Set(i);
+    return Array.from(s).join(" ").trim();
+  }
+  /**
+   * Sets the options for the step, maps `when` to events, sets up buttons
+   * @param options - The options for the step
+   */
+  _setOptions(t = {}) {
+    let n = this.tour && this.tour.options && this.tour.options.defaultStepOptions;
+    n = Vt({}, n || {}), this.options = Object.assign({
+      arrow: !0
+    }, n, t, ri(n, t));
+    const { when: r } = this.options;
+    this.options.classes = this._getClassOptions(t), this.destroy(), this.id = this.options.id || `step-${er()}`, r && Object.keys(r).forEach((o) => {
+      this.on(o, r[o], this);
+    });
+  }
+  /**
+   * Create the element and set up the FloatingUI instance
+   * @private
+   */
+  _setupElements() {
+    V(this.el) || this.destroy(), this.el = this._createTooltipContent(), this.options.advanceOn && po(this), ni(this);
+  }
+  /**
+   * Triggers `before-show`, generates the tooltip DOM content,
+   * sets up a FloatingUI instance for the tooltip, then triggers `show`.
+   * @private
+   */
+  _show() {
+    var r;
+    this.trigger("before-show"), this._resolveAttachToOptions(), this._setupElements(), this.tour.modal || this.tour.setupModal(), (r = this.tour.modal) == null || r.setupForStep(this), this._styleTargetElementForStep(this), this.el && (this.el.hidden = !1), this.options.scrollTo && setTimeout(() => {
+      this._scrollTo(this.options.scrollTo);
+    }), this.el && (this.el.hidden = !1);
+    const t = this.shepherdElementComponent.getElement(), n = this.target || document.body;
+    n.classList.add(`${this.classPrefix}shepherd-enabled`), n.classList.add(`${this.classPrefix}shepherd-target`), t.classList.add("shepherd-enabled"), this.trigger("show");
+  }
+  /**
+   * Modulates the styles of the passed step's target element, based on the step's options and
+   * the tour's `modal` option, to visually emphasize the element
+   *
+   * @param {Step} step The step object that attaches to the element
+   * @private
+   */
+  _styleTargetElementForStep(t) {
+    const n = t.target;
+    n && (t.options.highlightClass && n.classList.add(t.options.highlightClass), n.classList.remove("shepherd-target-click-disabled"), t.options.canClickTarget === !1 && n.classList.add("shepherd-target-click-disabled"));
+  }
+  /**
+   * When a step is hidden, remove the highlightClass and 'shepherd-enabled'
+   * and 'shepherd-target' classes
+   * @private
+   */
+  _updateStepTargetOnHide() {
+    const t = this.target || document.body;
+    this.options.highlightClass && t.classList.remove(this.options.highlightClass), t.classList.remove("shepherd-target-click-disabled", `${this.classPrefix}shepherd-enabled`, `${this.classPrefix}shepherd-target`);
+  }
+}
+function Zi(e) {
+  let t = {};
+  if (e.navigator) {
+    const n = e.navigator.userAgent;
+    t = {
+      ...t,
+      $os: es(e),
+      $browser: mr(n, e.navigator.vendor, !!e.opera),
+      $referrer: e.document.referrer,
+      $referring_domain: ns(e.document.referrer),
+      $device: ts(n),
+      $current_url: e.location.href,
+      $host: e.location.host,
+      $pathname: e.location.pathname,
+      $browser_version: Qi(n, e.navigator.vendor, !!e.opera),
+      $screen_height: e.screen.height,
+      $screen_width: e.screen.width,
+      $screen_dpr: e.devicePixelRatio
+    };
+  }
+  return t = {
+    ...t,
+    $lib: "js",
+    // $lib_version: version,
+    $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),
+    $time: (/* @__PURE__ */ new Date()).getTime() / 1e3
+    // epoch time in seconds
+  }, t;
+}
+function F(e, t) {
+  return e.indexOf(t) >= 0;
+}
+function mr(e, t, n) {
+  return t = t || "", n || F(e, " OPR/") ? F(e, "Mini") ? "Opera Mini" : "Opera" : /(BlackBerry|PlayBook|BB10)/i.test(e) ? "BlackBerry" : F(e, "IEMobile") || F(e, "WPDesktop") ? "Internet Explorer Mobile" : F(e, "SamsungBrowser/") ? "Samsung Internet" : F(e, "Edge") || F(e, "Edg/") ? "Microsoft Edge" : F(e, "FBIOS") ? "Facebook Mobile" : F(e, "Chrome") ? "Chrome" : F(e, "CriOS") ? "Chrome iOS" : F(e, "UCWEB") || F(e, "UCBrowser") ? "UC Browser" : F(e, "FxiOS") ? "Firefox iOS" : F(t, "Apple") ? F(e, "Mobile") ? "Mobile Safari" : "Safari" : F(e, "Android") ? "Android Mobile" : F(e, "Konqueror") ? "Konqueror" : F(e, "Firefox") ? "Firefox" : F(e, "MSIE") || F(e, "Trident/") ? "Internet Explorer" : F(e, "Gecko") ? "Mozilla" : "";
+}
+function Qi(e, t, n) {
+  const r = {
+    "Internet Explorer Mobile": /rv:(\d+(\.\d+)?)/,
+    "Microsoft Edge": /Edge?\/(\d+(\.\d+)?)/,
+    Chrome: /Chrome\/(\d+(\.\d+)?)/,
+    "Chrome iOS": /CriOS\/(\d+(\.\d+)?)/,
+    "UC Browser": /(UCBrowser|UCWEB)\/(\d+(\.\d+)?)/,
+    Safari: /Version\/(\d+(\.\d+)?)/,
+    "Mobile Safari": /Version\/(\d+(\.\d+)?)/,
+    Opera: /(Opera|OPR)\/(\d+(\.\d+)?)/,
+    Firefox: /Firefox\/(\d+(\.\d+)?)/,
+    "Firefox iOS": /FxiOS\/(\d+(\.\d+)?)/,
+    Konqueror: /Konqueror:(\d+(\.\d+)?)/,
+    BlackBerry: /BlackBerry (\d+(\.\d+)?)/,
+    "Android Mobile": /android\s(\d+(\.\d+)?)/,
+    "Samsung Internet": /SamsungBrowser\/(\d+(\.\d+)?)/,
+    "Internet Explorer": /(rv:|MSIE )(\d+(\.\d+)?)/,
+    Mozilla: /rv:(\d+(\.\d+)?)/
+  }, o = mr(e, t, n), i = r[o] || void 0;
+  if (i === void 0)
+    return null;
+  const s = e.match(i);
+  return s ? parseFloat(s[s.length - 2]) : null;
+}
+function es(e) {
+  const t = e.navigator.userAgent;
+  return /Windows/i.test(t) ? /Phone/.test(t) || /WPDesktop/.test(t) ? "Windows Phone" : "Windows" : /(iPhone|iPad|iPod)/.test(t) ? "iOS" : /Android/.test(t) ? "Android" : /(BlackBerry|PlayBook|BB10)/i.test(t) ? "BlackBerry" : /Mac/i.test(t) ? "Mac OS X" : /Linux/.test(t) ? "Linux" : /CrOS/.test(t) ? "Chrome OS" : "";
+}
+function ts(e) {
+  return /Windows Phone/i.test(e) || /WPDesktop/.test(e) ? "Windows Phone" : /iPad/.test(e) ? "iPad" : /iPod/.test(e) ? "iPod Touch" : /iPhone/.test(e) ? "iPhone" : /(BlackBerry|PlayBook|BB10)/i.test(e) ? "BlackBerry" : /Android/.test(e) ? "Android" : "";
+}
+function ns(e) {
+  const t = e.split("/");
+  return t.length >= 3 ? t[2] : "";
+}
+function rs(e) {
+  if (e) {
+    const { steps: t } = e;
+    t.forEach((n) => {
+      n.options && n.options.canClickTarget === !1 && n.options.attachTo && ze(n.target) && n.target.classList.remove("shepherd-target-click-disabled");
+    });
+  }
+}
+const Dt = (e, t) => t.some((n) => e instanceof n);
+let Wn, Nn;
+function os() {
+  return Wn || (Wn = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
+}
+function is() {
+  return Nn || (Nn = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
+}
+const Ft = /* @__PURE__ */ new WeakMap(), Ct = /* @__PURE__ */ new WeakMap(), pt = /* @__PURE__ */ new WeakMap();
+function ss(e) {
+  const t = new Promise((n, r) => {
+    const o = () => {
+      e.removeEventListener("success", i), e.removeEventListener("error", s);
+    }, i = () => {
+      n(Se(e.result)), o();
+    }, s = () => {
+      r(e.error), o();
+    };
+    e.addEventListener("success", i), e.addEventListener("error", s);
+  });
+  return pt.set(t, e), t;
+}
+function as(e) {
+  if (Ft.has(e))
+    return;
+  const t = new Promise((n, r) => {
+    const o = () => {
+      e.removeEventListener("complete", i), e.removeEventListener("error", s), e.removeEventListener("abort", s);
+    }, i = () => {
+      n(), o();
+    }, s = () => {
+      r(e.error || new DOMException("AbortError", "AbortError")), o();
+    };
+    e.addEventListener("complete", i), e.addEventListener("error", s), e.addEventListener("abort", s);
+  });
+  Ft.set(e, t);
+}
+let Lt = {
+  get(e, t, n) {
+    if (e instanceof IDBTransaction) {
+      if (t === "done")
+        return Ft.get(e);
+      if (t === "store")
+        return n.objectStoreNames[1] ? void 0 : n.objectStore(n.objectStoreNames[0]);
+    }
+    return Se(e[t]);
+  },
+  set(e, t, n) {
+    return e[t] = n, !0;
+  },
+  has(e, t) {
+    return e instanceof IDBTransaction && (t === "done" || t === "store") ? !0 : t in e;
+  }
+};
+function gr(e) {
+  Lt = e(Lt);
+}
+function cs(e) {
+  return is().includes(e) ? function(...t) {
+    return e.apply(jt(this), t), Se(this.request);
+  } : function(...t) {
+    return Se(e.apply(jt(this), t));
+  };
+}
+function ls(e) {
+  return typeof e == "function" ? cs(e) : (e instanceof IDBTransaction && as(e), Dt(e, os()) ? new Proxy(e, Lt) : e);
+}
+function Se(e) {
+  if (e instanceof IDBRequest)
+    return ss(e);
+  if (Ct.has(e))
+    return Ct.get(e);
+  const t = ls(e);
+  return t !== e && (Ct.set(e, t), pt.set(t, e)), t;
+}
+const jt = (e) => pt.get(e);
+function us(e, t, {
+  blocked: n,
+  upgrade: r,
+  blocking: o,
+  terminated: i
+} = {}) {
+  const s = indexedDB.open(e, t), c = Se(s);
+  return r && s.addEventListener("upgradeneeded", (l) => {
+    r(Se(s.result), l.oldVersion, l.newVersion, Se(s.transaction), l);
+  }), n && s.addEventListener("blocked", (l) => n(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    l.oldVersion,
+    l.newVersion,
+    l
+  )), c.then((l) => {
+    i && l.addEventListener("close", () => i()), o && l.addEventListener("versionchange", (u) => o(u.oldVersion, u.newVersion, u));
+  }).catch(() => {
+  }), c;
+}
+const fs = ["get", "getKey", "getAll", "getAllKeys", "count"], ds = ["put", "add", "delete", "clear"], Tt = /* @__PURE__ */ new Map();
+function Vn(e, t) {
+  if (!(e instanceof IDBDatabase && !(t in e) && typeof t == "string"))
+    return;
+  if (Tt.get(t))
+    return Tt.get(t);
+  const n = t.replace(/FromIndex$/, ""), r = t !== n, o = ds.includes(n);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(n in (r ? IDBIndex : IDBObjectStore).prototype) || !(o || fs.includes(n))
+  )
+    return;
+  const i = async function(c, ...l) {
+    const u = this.transaction(c, o ? "readwrite" : "readonly");
+    let f = u.store;
+    return r && (f = f.index(l.shift())), (await Promise.all([f[n](...l), o && u.done]))[0];
+  };
+  return Tt.set(t, i), i;
+}
+gr((e) => B({}, e, {
+  get: (t, n, r) => Vn(t, n) || e.get(t, n, r),
+  has: (t, n) => !!Vn(t, n) || e.has(t, n)
+}));
+const hs = ["continue", "continuePrimaryKey", "advance"], Un = {}, Bt = /* @__PURE__ */ new WeakMap(), br = /* @__PURE__ */ new WeakMap(), ps = {
+  get(e, t) {
+    if (!hs.includes(t))
+      return e[t];
+    let n = Un[t];
+    return n || (n = Un[t] = function(...r) {
+      Bt.set(this, br.get(this)[t](...r));
+    }), n;
+  }
+};
+function ms() {
+  return $t.apply(this, arguments);
+}
+function $t() {
+  return $t = Xr(function* (...e) {
+    let t = this;
+    if (t instanceof IDBCursor || (t = yield yn(t.openCursor(...e))), !t)
+      return;
+    t = t;
+    const n = new Proxy(t, ps);
+    for (br.set(n, t), pt.set(n, jt(t)); t; )
+      yield n, t = yield yn(Bt.get(n) || t.continue()), Bt.delete(n);
+  }), $t.apply(this, arguments);
+}
+function Hn(e, t) {
+  return t === Symbol.asyncIterator && Dt(e, [IDBIndex, IDBObjectStore, IDBCursor]) || t === "iterate" && Dt(e, [IDBIndex, IDBObjectStore]);
+}
+gr((e) => B({}, e, {
+  get(t, n, r) {
+    return Hn(t, n) ? ms : e.get(t, n, r);
+  },
+  has(t, n) {
+    return Hn(t, n) || e.has(t, n);
+  }
+}));
+class gs {
+  constructor(t, n, r) {
+    if (!t)
+      throw new Error("Shepherd Pro: Missing required apiKey option.");
+    if (!n)
+      throw new Error("Shepherd Pro: Missing required apiPath option.");
+    this.apiKey = t, this.apiPath = n, this.properties = r;
+  }
+  /**
+   * Gets a list of the state for all the tours associated with a given apiKey
+   */
+  async getTourState() {
+    try {
+      const t = await fetch(`${this.apiPath}/api/v1/state`, {
+        headers: {
+          Authorization: `ApiKey ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        method: "GET"
+      });
+      if (!t.ok)
+        throw new Error("Could not fetch state for tours 🐑");
+      const { data: n } = await t.json();
+      if (this.tourStateDb = await us("TourState", 1, {
+        upgrade(r) {
+          r.createObjectStore("tours", {
+            keyPath: "uniqueId"
+          });
+        }
+      }), Array.isArray(n) && n.length) {
+        const r = this.tourStateDb.transaction("tours", "readwrite"), o = n.map((i) => r.store.put(i));
+        await Promise.all([...o, r.done]);
+      }
+    } catch (t) {
+      throw new Error("Error fetching data: " + (t instanceof Error ? t.message : "Unknown error"));
+    }
+  }
+  /**
+   * Send events to the ShepherdPro API
+   * @param body The data to send for the event
+   */
+  async sendEvents(t) {
+    t.data.properties = this.properties;
+    try {
+      const n = await fetch(`${this.apiPath}/api/v1/actor`, {
+        headers: {
+          Authorization: `ApiKey ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        method: "POST",
+        body: JSON.stringify(t)
+      });
+      if (!n.ok)
+        throw new Error("Could not create an event 🐑");
+      const { data: r } = await n.json();
+      return r;
+    } catch (n) {
+      throw new Error("Error fetching data: " + (n instanceof Error ? n.message : "Unknown error"));
+    }
+  }
+}
+function bs({ width: e, height: t, x: n = 0, y: r = 0, r: o = 0 }) {
+  const { innerWidth: i, innerHeight: s } = window, { topLeft: c = 0, topRight: l = 0, bottomRight: u = 0, bottomLeft: f = 0 } = typeof o == "number" ? { topLeft: o, topRight: o, bottomRight: o, bottomLeft: o } : o;
+  return `M${i},${s}H0V0H${i}V${s}ZM${n + c},${r}a${c},${c},0,0,0-${c},${c}V${t + r - f}a${f},${f},0,0,0,${f},${f}H${e + n - u}a${u},${u},0,0,0,${u}-${u}V${r + l}a${l},${l},0,0,0-${l}-${l}Z`;
+}
+function ys(e) {
+  let t, n, r, o, i;
+  return {
+    c() {
+      t = Cn("svg"), n = Cn("path"), A(
+        n,
+        "d",
+        /*pathDefinition*/
+        e[2]
+      ), A(t, "class", r = `${/*modalIsVisible*/
+      e[1] ? "shepherd-modal-is-visible" : ""} shepherd-modal-overlay-container`);
+    },
+    m(s, c) {
+      re(s, t, c), Be(t, n), e[11](t), o || (i = ht(
+        t,
+        "touchmove",
+        /*_preventModalOverlayTouch*/
+        e[3]
+      ), o = !0);
+    },
+    p(s, [c]) {
+      c & /*pathDefinition*/
+      4 && A(
+        n,
+        "d",
+        /*pathDefinition*/
+        s[2]
+      ), c & /*modalIsVisible*/
+      2 && r !== (r = `${/*modalIsVisible*/
+      s[1] ? "shepherd-modal-is-visible" : ""} shepherd-modal-overlay-container`) && A(t, "class", r);
+    },
+    i: K,
+    o: K,
+    d(s) {
+      s && ee(t), e[11](null), o = !1, i();
+    }
+  };
+}
+function yr(e) {
+  if (!e)
+    return null;
+  const n = e instanceof HTMLElement && window.getComputedStyle(e).overflowY;
+  return n !== "hidden" && n !== "visible" && e.scrollHeight >= e.clientHeight ? e : yr(e.parentElement);
+}
+function vs(e) {
+  let t = {
+    top: 0,
+    left: 0
+  };
+  if (!e)
+    return t;
+  let n = e.ownerDocument.defaultView;
+  for (; n !== window.top; ) {
+    var r;
+    const s = (r = n) == null ? void 0 : r.frameElement;
+    if (s) {
+      var o, i;
+      const c = s.getBoundingClientRect();
+      t.top += c.top + ((o = c.scrollTop) != null ? o : 0), t.left += c.left + ((i = c.scrollLeft) != null ? i : 0);
+    }
+    n = n.parent;
+  }
+  return t;
+}
+function ws(e, t) {
+  const n = e.getBoundingClientRect();
+  let r = n.y || n.top, o = n.bottom || r + n.height;
+  if (t) {
+    const s = t.getBoundingClientRect(), c = s.y || s.top, l = s.bottom || c + s.height;
+    r = Math.max(r, c), o = Math.min(o, l);
+  }
+  const i = Math.max(o - r, 0);
+  return {
+    y: r,
+    height: i
+  };
+}
+function _s(e, t, n) {
+  let {
+    element: r,
+    openingProperties: o
+  } = t, i = !1, s, c;
+  u();
+  const l = () => r;
+  function u() {
+    n(4, o = {
+      width: 0,
+      height: 0,
+      x: 0,
+      y: 0,
+      r: 0
+    });
+  }
+  function f() {
+    n(1, i = !1), w();
+  }
+  function h(v = 0, g = 0, T = 0, N = 0, te, $) {
+    if ($) {
+      const {
+        y: H,
+        height: z
+      } = ws($, te), {
+        x: J,
+        width: W,
+        left: M
+      } = $.getBoundingClientRect();
+      n(4, o = {
+        width: W + v * 2,
+        height: z + v * 2,
+        x: (J || M) + T - v,
+        y: H + N - v,
+        r: g
+      });
+    } else
+      u();
+  }
+  function d(v) {
+    w(), v.tour.options.useModalOverlay ? (_(v), m()) : f();
+  }
+  function m() {
+    n(1, i = !0);
+  }
+  const y = (v) => {
+    v.preventDefault();
+  }, E = (v) => {
+    v.stopPropagation();
+  };
+  function S() {
+    window.addEventListener("touchmove", y, {
+      passive: !1
+    });
+  }
+  function w() {
+    s && (cancelAnimationFrame(s), s = void 0), window.removeEventListener("touchmove", y, {
+      passive: !1
+    });
+  }
+  function _(v) {
+    const {
+      modalOverlayOpeningPadding: g,
+      modalOverlayOpeningRadius: T,
+      modalOverlayOpeningXOffset: N = 0,
+      modalOverlayOpeningYOffset: te = 0
+    } = v.options, $ = vs(v.target), H = yr(v.target), z = () => {
+      s = void 0, h(g, T, N + $.left, te + $.top, H, v.target), s = requestAnimationFrame(z);
+    };
+    z(), S();
+  }
+  function C(v) {
+    $e[v ? "unshift" : "push"](() => {
+      r = v, n(0, r);
+    });
+  }
+  return e.$$set = (v) => {
+    "element" in v && n(0, r = v.element), "openingProperties" in v && n(4, o = v.openingProperties);
+  }, e.$$.update = () => {
+    e.$$.dirty & /*openingProperties*/
+    16 && n(2, c = bs(o));
+  }, [r, i, c, E, o, l, u, f, h, d, m, C];
+}
+class Es extends de {
+  constructor(t) {
+    super(), fe(this, t, _s, ys, ue, {
+      element: 0,
+      openingProperties: 4,
+      getElement: 5,
+      closeModalOpening: 6,
+      hide: 7,
+      positionModal: 8,
+      setupForStep: 9,
+      show: 10
+    });
+  }
+  get getElement() {
+    return this.$$.ctx[5];
+  }
+  get closeModalOpening() {
+    return this.$$.ctx[6];
+  }
+  get hide() {
+    return this.$$.ctx[7];
+  }
+  get positionModal() {
+    return this.$$.ctx[8];
+  }
+  get setupForStep() {
+    return this.$$.ctx[9];
+  }
+  get show() {
+    return this.$$.ctx[10];
+  }
+}
+const xs = "https://shepherdpro.com", Wt = "shepherdPro:userId";
+class Ss extends Nt {
+  constructor() {
+    super(...arguments), this.isProEnabled = !1;
+  }
+  /**
+   * Call init to take full advantage of ShepherdPro functionality
+   * @param {string} apiKey The API key for your ShepherdPro account
+   * @param {string} apiPath
+   * @param {object} properties Extra properties to be passed to Shepherd Pro
+   */
+  async init(t, n, r) {
+    if (!t)
+      throw new Error("Shepherd Pro: Missing required apiKey option.");
+    if (this.apiKey = t, this.apiPath = n ?? xs, this.properties = r ?? {}, this.properties.context = Zi(window), this.apiKey) {
+      this.dataRequester = new gs(this.apiKey, this.apiPath, this.properties), this.isProEnabled = !0;
+      const o = localStorage.getItem(Wt), i = [this.dataRequester.getTourState()];
+      o || i.push(this.createNewActor()), await Promise.all(i);
+    }
+  }
+  async createNewActor() {
+    if (!this.dataRequester)
+      return;
+    const t = await this.dataRequester.sendEvents({
+      data: {
+        currentUserId: null,
+        eventType: "setup"
+      }
+    });
+    localStorage.setItem(Wt, String(t.actorId));
+  }
+  /**
+   * Checks if a given tour's id is enabled
+   * @param tourId A string denoting the id of the tour
+   */
+  async isTourEnabled(t) {
+    var r;
+    if (!this.dataRequester)
+      return;
+    const n = await ((r = this.dataRequester.tourStateDb) == null ? void 0 : r.get("tours", t));
+    return (n == null ? void 0 : n.isActive) ?? !0;
+  }
+}
+class Os extends Nt {
+  constructor(t = {}) {
+    super(), this.trackedEvents = ["active", "cancel", "complete", "show"], Xn(this);
+    const n = {
+      exitOnEsc: !0,
+      keyboardNavigation: !0
+    };
+    this.options = Object.assign({}, n, t), this.classPrefix = Zn(this.options.classPrefix), this.steps = [], this.addSteps(this.options.steps), [
+      "active",
+      "cancel",
+      "complete",
+      "inactive",
+      "show",
+      "start"
+    ].map((i) => {
+      ((s) => {
+        this.on(s, (c) => {
+          c = c || {}, c.tour = this, ne.trigger(s, c);
+        });
+      })(i);
+    }), this._setTourID(t.id);
+    const { dataRequester: o } = ne;
+    return o && this.trackedEvents.forEach((i) => this.on(i, (s) => {
+      const { tour: c } = s, { id: l, steps: u } = c;
+      let f;
+      if (i !== "active") {
+        const { step: d } = s;
+        d && (f = u.findIndex((m) => m.id === d.id) + 1);
+      }
+      const h = {
+        currentUserId: localStorage.getItem(Wt),
+        eventType: i,
+        journeyData: {
+          id: l,
+          currentStep: f,
+          numberOfSteps: u.length,
+          tourOptions: c.options
+        }
+      };
+      o.sendEvents({ data: h });
+    })), this;
+  }
+  /**
+   * Adds a new step to the tour
+   * @param {StepOptions} options - An object containing step options or a Step instance
+   * @param {number | undefined} index - The optional index to insert the step at. If undefined, the step
+   * is added to the end of the array.
+   * @return The newly added step
+   */
+  addStep(t, n) {
+    let r = t;
+    return r instanceof Mt ? r.tour = this : r = new Mt(this, r), V(n) ? this.steps.push(r) : this.steps.splice(n, 0, r), r;
+  }
+  /**
+   * Add multiple steps to the tour
+   * @param {Array<StepOptions> | Array<Step> | undefined} steps - The steps to add to the tour
+   */
+  addSteps(t) {
+    return Array.isArray(t) && t.forEach((n) => {
+      this.addStep(n);
+    }), this;
+  }
+  /**
+   * Go to the previous step in the tour
+   */
+  back() {
+    const t = this.steps.indexOf(this.currentStep);
+    this.show(t - 1, !1);
+  }
+  /**
+   * Calls _done() triggering the 'cancel' event
+   * If `confirmCancel` is true, will show a window.confirm before cancelling
+   * If `confirmCancel` is a function, will call it and wait for the return value,
+   * and only cancel when the value returned is true
+   */
+  async cancel() {
+    if (this.options.confirmCancel) {
+      const t = this.options.confirmCancelMessage || "Are you sure you want to stop the tour?";
+      let n;
+      pe(this.options.confirmCancel) ? n = await this.options.confirmCancel() : n = window.confirm(t), n && this._done("cancel");
+    } else
+      this._done("cancel");
+  }
+  /**
+   * Calls _done() triggering the `complete` event
+   */
+  complete() {
+    this._done("complete");
+  }
+  /**
+   * Gets the step from a given id
+   * @param {number | string} id - The id of the step to retrieve
+   * @return The step corresponding to the `id`
+   */
+  getById(t) {
+    return this.steps.find((n) => n.id === t);
+  }
+  /**
+   * Gets the current step
+   */
+  getCurrentStep() {
+    return this.currentStep;
+  }
+  /**
+   * Hide the current step
+   */
+  hide() {
+    const t = this.getCurrentStep();
+    if (t)
+      return t.hide();
+  }
+  /**
+   * Check if the tour is active
+   */
+  isActive() {
+    return ne.activeTour === this;
+  }
+  /**
+   * Go to the next step in the tour
+   * If we are at the end, call `complete`
+   */
+  next() {
+    const t = this.steps.indexOf(this.currentStep);
+    t === this.steps.length - 1 ? this.complete() : this.show(t + 1, !0);
+  }
+  /**
+   * Removes the step from the tour
+   * @param {string} name - The id for the step to remove
+   */
+  removeStep(t) {
+    const n = this.getCurrentStep();
+    this.steps.some((r, o) => {
+      if (r.id === t)
+        return r.isOpen() && r.hide(), r.destroy(), this.steps.splice(o, 1), !0;
+    }), n && n.id === t && (this.currentStep = void 0, this.steps.length ? this.show(0) : this.cancel());
+  }
+  /**
+   * Show a specific step in the tour
+   * @param {number | string} key - The key to look up the step by
+   * @param {boolean} forward - True if we are going forward, false if backward
+   */
+  show(t = 0, n = !0) {
+    const r = Ye(t) ? this.getById(t) : this.steps[t];
+    r && (this._updateStateBeforeShow(), pe(r.options.showOn) && !r.options.showOn() ? this._skipStep(r, n) : (this.trigger("show", {
+      step: r,
+      previous: this.currentStep
+    }), this.currentStep = r, r.show()));
+  }
+  /**
+   * Start the tour
+   */
+  async start() {
+    ne.isProEnabled && !await ne.isTourEnabled(this.options.id) || (this.trigger("start"), this.focusedElBeforeOpen = document.activeElement, this.currentStep = null, this.setupModal(), this._setupActiveTour(), this.next());
+  }
+  /**
+   * Called whenever the tour is cancelled or completed, basically anytime we exit the tour
+   * @param {string} event - The event name to trigger
+   * @private
+   */
+  _done(t) {
+    const n = this.steps.indexOf(this.currentStep);
+    if (Array.isArray(this.steps) && this.steps.forEach((r) => r.destroy()), rs(this), this.trigger(t, { index: n }), ne.activeTour = null, this.trigger("inactive", { tour: this }), this.modal && this.modal.hide(), (t === "cancel" || t === "complete") && this.modal) {
+      const r = document.querySelector(".shepherd-modal-overlay-container");
+      r && r.remove();
+    }
+    ze(this.focusedElBeforeOpen) && this.focusedElBeforeOpen.focus();
+  }
+  /**
+   * Make this tour "active"
+   */
+  _setupActiveTour() {
+    this.trigger("active", { tour: this }), ne.activeTour = this;
+  }
+  /**
+   * setupModal create the modal container and instance
+   */
+  setupModal() {
+    this.modal = new Es({
+      target: this.options.modalContainer || document.body,
+      props: {
+        // @ts-expect-error TODO: investigate where styles comes from
+        styles: this.styles
+      }
+    });
+  }
+  /**
+   * Called when `showOn` evaluates to false, to skip the step or complete the tour if it's the last step
+   * @param {Step} step - The step to skip
+   * @param {boolean} forward - True if we are going forward, false if backward
+   * @private
+   */
+  _skipStep(t, n) {
+    const r = this.steps.indexOf(t);
+    if (r === this.steps.length - 1)
+      this.complete();
+    else {
+      const o = n ? r + 1 : r - 1;
+      this.show(o, n);
+    }
+  }
+  /**
+   * Before showing, hide the current step and if the tour is not
+   * already active, call `this._setupActiveTour`.
+   * @private
+   */
+  _updateStateBeforeShow() {
+    this.currentStep && this.currentStep.hide(), this.isActive() || this._setupActiveTour();
+  }
+  /**
+   * Sets this.id to a provided tourName and id or `${tourName}--${uuid}`
+   * @param {string} optionsId - True if we are going forward, false if backward
+   * @private
+   */
+  _setTourID(t) {
+    const n = this.options.tourName || "tour", r = t || er();
+    this.id = `${n}--${r}`;
+  }
+}
+const ne = new Ss(), vr = typeof window > "u";
+ne.Step = vr ? mo : Mt;
+ne.Tour = vr ? go : Os;
+const Xt = Yr(
+  void 0
+), Ts = Xt.Consumer, Rs = () => {
+  const e = qr(Xt);
+  if (!e)
+    throw new Error(
+      "useShepherd must be used within a ShepherdJourneyProvider"
+    );
+  const { Shepherd: t } = e;
+  return t;
+}, Ps = ({
+  apiKey: e,
+  children: t
+}) => (ne.init(e), /* @__PURE__ */ Jr.jsx(Xt.Provider, { value: { Shepherd: ne }, children: t }));
+export {
+  Ts as JourneyMethods,
+  Xt as ShepherdJourneyContext,
+  Ps as ShepherdJourneyProvider,
+  Rs as useShepherd
+};