@kakadu/components 0.1.4 → 1.0.1

package/build/modal.mjs

@@ -0,0 +1,1246 @@
+import { j as C } from "./jsx-runtime-B4hRZ52C.mjs";
+import Ie, { createContext as Ae, useRef as te, useState as re, useCallback as J, useMemo as ne, useEffect as H, useContext as je } from "react";
+import { cx as pe } from "@kuma-ui/core";
+import { createPortal as xe } from "react-dom";
+import { IconType as _e } from "./icon.mjs";
+import Le from "./theme.mjs";
+import Be from "./text-button.mjs";
+function we(r) {
+  if (Object.prototype.hasOwnProperty.call(r, "__esModule")) return r;
+  var e = r.default;
+  if (typeof e == "function") {
+    var t = function a() {
+      return this instanceof a ? Reflect.construct(e, arguments, this.constructor) : e.apply(this, arguments);
+    };
+    t.prototype = e.prototype;
+  } else t = {};
+  return Object.defineProperty(t, "__esModule", { value: !0 }), Object.keys(r).forEach(function(a) {
+    var u = Object.getOwnPropertyDescriptor(r, a);
+    Object.defineProperty(t, a, u.get ? u : {
+      enumerable: !0,
+      get: function() {
+        return r[a];
+      }
+    });
+  }), t;
+}
+var Q = { exports: {} };
+/*!
+* tabbable 6.4.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var ke = ["input:not([inert]):not([inert] *)", "select:not([inert]):not([inert] *)", "textarea:not([inert]):not([inert] *)", "a[href]:not([inert]):not([inert] *)", "button:not([inert]):not([inert] *)", "[tabindex]:not(slot):not([inert]):not([inert] *)", "audio[controls]:not([inert]):not([inert] *)", "video[controls]:not([inert]):not([inert] *)", '[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)', "details>summary:first-of-type:not([inert]):not([inert] *)", "details:not([inert]):not([inert] *)"], ie = /* @__PURE__ */ ke.join(","), Ee = typeof Element > "u", W = Ee ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, oe = !Ee && Element.prototype.getRootNode ? function(r) {
+  var e;
+  return r == null || (e = r.getRootNode) === null || e === void 0 ? void 0 : e.call(r);
+} : function(r) {
+  return r == null ? void 0 : r.ownerDocument;
+}, ue = function(e, t) {
+  var a;
+  t === void 0 && (t = !0);
+  var u = e == null || (a = e.getAttribute) === null || a === void 0 ? void 0 : a.call(e, "inert"), l = u === "" || u === "true", n = l || t && e && // closest does not exist on shadow roots, so we fall back to a manual
+  // lookup upward, in case it is not defined.
+  (typeof e.closest == "function" ? e.closest("[inert]") : ue(e.parentNode));
+  return n;
+}, Me = function(e) {
+  var t, a = e == null || (t = e.getAttribute) === null || t === void 0 ? void 0 : t.call(e, "contenteditable");
+  return a === "" || a === "true";
+}, Fe = function(e, t, a) {
+  if (ue(e))
+    return [];
+  var u = Array.prototype.slice.apply(e.querySelectorAll(ie));
+  return t && W.call(e, ie) && u.unshift(e), u = u.filter(a), u;
+}, se = function(e, t, a) {
+  for (var u = [], l = Array.from(e); l.length; ) {
+    var n = l.shift();
+    if (!ue(n, !1))
+      if (n.tagName === "SLOT") {
+        var p = n.assignedElements(), y = p.length ? p : n.children, k = se(y, !0, a);
+        a.flatten ? u.push.apply(u, k) : u.push({
+          scopeParent: n,
+          candidates: k
+        });
+      } else {
+        var S = W.call(n, ie);
+        S && a.filter(n) && (t || !e.includes(n)) && u.push(n);
+        var D = n.shadowRoot || // check for an undisclosed shadow
+        typeof a.getShadowRoot == "function" && a.getShadowRoot(n), R = !ue(D, !1) && (!a.shadowRootFilter || a.shadowRootFilter(n));
+        if (D && R) {
+          var j = se(D === !0 ? n.children : D.children, !0, a);
+          a.flatten ? u.push.apply(u, j) : u.push({
+            scopeParent: n,
+            candidates: j
+          });
+        } else
+          l.unshift.apply(l, n.children);
+      }
+  }
+  return u;
+}, Se = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, q = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || Me(e)) && !Se(e) ? 0 : e.tabIndex;
+}, Ke = function(e, t) {
+  var a = q(e);
+  return a < 0 && t && !Se(e) ? 0 : a;
+}, qe = function(e, t) {
+  return e.tabIndex === t.tabIndex ? e.documentOrder - t.documentOrder : e.tabIndex - t.tabIndex;
+}, Oe = function(e) {
+  return e.tagName === "INPUT";
+}, Ve = function(e) {
+  return Oe(e) && e.type === "hidden";
+}, $e = function(e) {
+  var t = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(a) {
+    return a.tagName === "SUMMARY";
+  });
+  return t;
+}, Ge = function(e, t) {
+  for (var a = 0; a < e.length; a++)
+    if (e[a].checked && e[a].form === t)
+      return e[a];
+}, Ue = function(e) {
+  if (!e.name)
+    return !0;
+  var t = e.form || oe(e), a = function(p) {
+    return t.querySelectorAll('input[type="radio"][name="' + p + '"]');
+  }, u;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    u = a(window.CSS.escape(e.name));
+  else
+    try {
+      u = a(e.name);
+    } catch (n) {
+      return console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", n.message), !1;
+    }
+  var l = Ge(u, e.form);
+  return !l || l === e;
+}, We = function(e) {
+  return Oe(e) && e.type === "radio";
+}, ze = function(e) {
+  return We(e) && !Ue(e);
+}, Ye = function(e) {
+  var t, a = e && oe(e), u = (t = a) === null || t === void 0 ? void 0 : t.host, l = !1;
+  if (a && a !== e) {
+    var n, p, y;
+    for (l = !!((n = u) !== null && n !== void 0 && (p = n.ownerDocument) !== null && p !== void 0 && p.contains(u) || e != null && (y = e.ownerDocument) !== null && y !== void 0 && y.contains(e)); !l && u; ) {
+      var k, S, D;
+      a = oe(u), u = (k = a) === null || k === void 0 ? void 0 : k.host, l = !!((S = u) !== null && S !== void 0 && (D = S.ownerDocument) !== null && D !== void 0 && D.contains(u));
+    }
+  }
+  return l;
+}, be = function(e) {
+  var t = e.getBoundingClientRect(), a = t.width, u = t.height;
+  return a === 0 && u === 0;
+}, He = function(e, t) {
+  var a = t.displayCheck, u = t.getShadowRoot;
+  if (a === "full-native" && "checkVisibility" in e) {
+    var l = e.checkVisibility({
+      // Checking opacity might be desirable for some use cases, but natively,
+      // opacity zero elements _are_ focusable and tabbable.
+      checkOpacity: !1,
+      opacityProperty: !1,
+      contentVisibilityAuto: !0,
+      visibilityProperty: !0,
+      // This is an alias for `visibilityProperty`. Contemporary browsers
+      // support both. However, this alias has wider browser support (Chrome
+      // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so
+      // we include it anyway.
+      checkVisibilityCSS: !0
+    });
+    return !l;
+  }
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var n = W.call(e, "details>summary:first-of-type"), p = n ? e.parentElement : e;
+  if (W.call(p, "details:not([open]) *"))
+    return !0;
+  if (!a || a === "full" || // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  a === "full-native" || a === "legacy-full") {
+    if (typeof u == "function") {
+      for (var y = e; e; ) {
+        var k = e.parentElement, S = oe(e);
+        if (k && !k.shadowRoot && u(k) === !0)
+          return be(e);
+        e.assignedSlot ? e = e.assignedSlot : !k && S !== e.ownerDocument ? e = S.host : e = k;
+      }
+      e = y;
+    }
+    if (Ye(e))
+      return !e.getClientRects().length;
+    if (a !== "legacy-full")
+      return !0;
+  } else if (a === "non-zero-area")
+    return be(e);
+  return !1;
+}, Ze = function(e) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))
+    for (var t = e.parentElement; t; ) {
+      if (t.tagName === "FIELDSET" && t.disabled) {
+        for (var a = 0; a < t.children.length; a++) {
+          var u = t.children.item(a);
+          if (u.tagName === "LEGEND")
+            return W.call(t, "fieldset[disabled] *") ? !0 : !u.contains(e);
+        }
+        return !0;
+      }
+      t = t.parentElement;
+    }
+  return !1;
+}, ce = function(e, t) {
+  return !(t.disabled || Ve(t) || He(t, e) || // For a details element with a summary, the summary element gets the focus
+  $e(t) || Ze(t));
+}, de = function(e, t) {
+  return !(ze(t) || q(t) < 0 || !ce(e, t));
+}, Xe = function(e) {
+  var t = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(t) || t >= 0);
+}, De = function(e) {
+  var t = [], a = [];
+  return e.forEach(function(u, l) {
+    var n = !!u.scopeParent, p = n ? u.scopeParent : u, y = Ke(p, n), k = n ? De(u.candidates) : p;
+    y === 0 ? n ? t.push.apply(t, k) : t.push(p) : a.push({
+      documentOrder: l,
+      tabIndex: y,
+      item: u,
+      isScope: n,
+      content: k
+    });
+  }), a.sort(qe).reduce(function(u, l) {
+    return l.isScope ? u.push.apply(u, l.content) : u.push(l.content), u;
+  }, []).concat(t);
+}, Ne = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = se([e], t.includeContainer, {
+    filter: de.bind(null, t),
+    flatten: !1,
+    getShadowRoot: t.getShadowRoot,
+    shadowRootFilter: Xe
+  }) : a = Fe(e, t.includeContainer, de.bind(null, t)), De(a);
+}, Re = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = se([e], t.includeContainer, {
+    filter: ce.bind(null, t),
+    flatten: !0,
+    getShadowRoot: t.getShadowRoot
+  }) : a = Fe(e, t.includeContainer, ce.bind(null, t)), a;
+}, U = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return W.call(e, ie) === !1 ? !1 : de(t, e);
+}, Je = /* @__PURE__ */ ke.concat("iframe:not([inert]):not([inert] *)").join(","), ae = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return W.call(e, Je) === !1 ? !1 : ce(t, e);
+};
+const Qe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  focusable: Re,
+  getTabIndex: q,
+  isFocusable: ae,
+  isTabbable: U,
+  tabbable: Ne
+}, Symbol.toStringTag, { value: "Module" }));
+/*!
+* focus-trap 7.8.0
+* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+*/
+function ve(r, e) {
+  (e == null || e > r.length) && (e = r.length);
+  for (var t = 0, a = Array(e); t < e; t++) a[t] = r[t];
+  return a;
+}
+function et(r) {
+  if (Array.isArray(r)) return ve(r);
+}
+function he(r, e) {
+  var t = typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = Pe(r)) || e) {
+      t && (r = t);
+      var a = 0, u = function() {
+      };
+      return {
+        s: u,
+        n: function() {
+          return a >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[a++]
+          };
+        },
+        e: function(y) {
+          throw y;
+        },
+        f: u
+      };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var l, n = !0, p = !1;
+  return {
+    s: function() {
+      t = t.call(r);
+    },
+    n: function() {
+      var y = t.next();
+      return n = y.done, y;
+    },
+    e: function(y) {
+      p = !0, l = y;
+    },
+    f: function() {
+      try {
+        n || t.return == null || t.return();
+      } finally {
+        if (p) throw l;
+      }
+    }
+  };
+}
+function tt(r, e, t) {
+  return (e = ot(e)) in r ? Object.defineProperty(r, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : r[e] = t, r;
+}
+function rt(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function at() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function ye(r, e) {
+  var t = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(r);
+    e && (a = a.filter(function(u) {
+      return Object.getOwnPropertyDescriptor(r, u).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function me(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? ye(Object(t), !0).forEach(function(a) {
+      tt(r, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(t)) : ye(Object(t)).forEach(function(a) {
+      Object.defineProperty(r, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return r;
+}
+function nt(r) {
+  return et(r) || rt(r) || Pe(r) || at();
+}
+function it(r, e) {
+  if (typeof r != "object" || !r) return r;
+  var t = r[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var a = t.call(r, e);
+    if (typeof a != "object") return a;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(r);
+}
+function ot(r) {
+  var e = it(r, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function Pe(r, e) {
+  if (r) {
+    if (typeof r == "string") return ve(r, e);
+    var t = {}.toString.call(r).slice(8, -1);
+    return t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set" ? Array.from(r) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? ve(r, e) : void 0;
+  }
+}
+var B = {
+  // Returns the trap from the top of the stack.
+  getActiveTrap: function(e) {
+    return (e == null ? void 0 : e.length) > 0 ? e[e.length - 1] : null;
+  },
+  // Pauses the currently active trap, then adds a new trap to the stack.
+  activateTrap: function(e, t) {
+    var a = B.getActiveTrap(e);
+    t !== a && B.pauseTrap(e);
+    var u = e.indexOf(t);
+    u === -1 || e.splice(u, 1), e.push(t);
+  },
+  // Removes the trap from the top of the stack, then unpauses the next trap down.
+  deactivateTrap: function(e, t) {
+    var a = e.indexOf(t);
+    a !== -1 && e.splice(a, 1), B.unpauseTrap(e);
+  },
+  // Pauses the trap at the top of the stack.
+  pauseTrap: function(e) {
+    var t = B.getActiveTrap(e);
+    t == null || t._setPausedState(!0);
+  },
+  // Unpauses the trap at the top of the stack.
+  unpauseTrap: function(e) {
+    var t = B.getActiveTrap(e);
+    t && !t._isManuallyPaused() && t._setPausedState(!1);
+  }
+}, ut = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, st = function(e) {
+  return (e == null ? void 0 : e.key) === "Escape" || (e == null ? void 0 : e.key) === "Esc" || (e == null ? void 0 : e.keyCode) === 27;
+}, X = function(e) {
+  return (e == null ? void 0 : e.key) === "Tab" || (e == null ? void 0 : e.keyCode) === 9;
+}, ct = function(e) {
+  return X(e) && !e.shiftKey;
+}, lt = function(e) {
+  return X(e) && e.shiftKey;
+}, ge = function(e) {
+  return setTimeout(e, 0);
+}, Z = function(e) {
+  for (var t = arguments.length, a = new Array(t > 1 ? t - 1 : 0), u = 1; u < t; u++)
+    a[u - 1] = arguments[u];
+  return typeof e == "function" ? e.apply(void 0, a) : e;
+}, ee = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, ft = [], dt = function(e, t) {
+  var a = (t == null ? void 0 : t.document) || document, u = (t == null ? void 0 : t.trapStack) || ft, l = me({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isolateSubtrees: !1,
+    isKeyForward: ct,
+    isKeyBackward: lt
+  }, t), n = {
+    // containers given to createFocusTrap()
+    /** @type {Array<HTMLElement>} */
+    containers: [],
+    // list of objects identifying tabbable nodes in `containers` in the trap
+    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap
+    //  is active, but the trap should never get to a state where there isn't at least one group
+    //  with at least one tabbable node in it (that would lead to an error condition that would
+    //  result in an error being thrown)
+    /** @type {Array<{
+     *    container: HTMLElement,
+     *    tabbableNodes: Array<HTMLElement>, // empty if none
+     *    focusableNodes: Array<HTMLElement>, // empty if none
+     *    posTabIndexesFound: boolean,
+     *    firstTabbableNode: HTMLElement|undefined,
+     *    lastTabbableNode: HTMLElement|undefined,
+     *    firstDomTabbableNode: HTMLElement|undefined,
+     *    lastDomTabbableNode: HTMLElement|undefined,
+     *    nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined
+     *  }>}
+     */
+    containerGroups: [],
+    // same order/length as `containers` list
+    // references to objects in `containerGroups`, but only those that actually have
+    //  tabbable nodes in them
+    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__
+    //  the same length
+    tabbableGroups: [],
+    // references to nodes that are siblings to the ancestors of this trap's containers.
+    /** @type {Set<HTMLElement>} */
+    adjacentElements: /* @__PURE__ */ new Set(),
+    // references to nodes that were inert or aria-hidden before the trap was activated.
+    /** @type {Set<HTMLElement>} */
+    alreadySilent: /* @__PURE__ */ new Set(),
+    nodeFocusedBeforeActivation: null,
+    mostRecentlyFocusedNode: null,
+    active: !1,
+    paused: !1,
+    manuallyPaused: !1,
+    // timer ID for when delayInitialFocus is true and initial focus in this trap
+    //  has been delayed during activation
+    delayInitialFocusTimer: void 0,
+    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any
+    recentNavEvent: void 0
+  }, p, y = function(o, i, f) {
+    return o && o[i] !== void 0 ? o[i] : l[f || i];
+  }, k = function(o, i) {
+    var f = typeof (i == null ? void 0 : i.composedPath) == "function" ? i.composedPath() : void 0;
+    return n.containerGroups.findIndex(function(g) {
+      var h = g.container, T = g.tabbableNodes;
+      return h.contains(o) || // fall back to explicit tabbable search which will take into consideration any
+      //  web components if the `tabbableOptions.getShadowRoot` option was used for
+      //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't
+      //  look inside web components even if open)
+      (f == null ? void 0 : f.includes(h)) || T.find(function(v) {
+        return v === o;
+      });
+    });
+  }, S = function(o) {
+    var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, f = i.hasFallback, g = f === void 0 ? !1 : f, h = i.params, T = h === void 0 ? [] : h, v = l[o];
+    if (typeof v == "function" && (v = v.apply(void 0, nt(T))), v === !0 && (v = void 0), !v) {
+      if (v === void 0 || v === !1)
+        return v;
+      throw new Error("`".concat(o, "` was specified but was not a node, or did not return a node"));
+    }
+    var E = v;
+    if (typeof v == "string") {
+      try {
+        E = a.querySelector(v);
+      } catch (F) {
+        throw new Error("`".concat(o, '` appears to be an invalid selector; error="').concat(F.message, '"'));
+      }
+      if (!E && !g)
+        throw new Error("`".concat(o, "` as selector refers to no known node"));
+    }
+    return E;
+  }, D = function() {
+    var o = S("initialFocus", {
+      hasFallback: !0
+    });
+    if (o === !1)
+      return !1;
+    if (o === void 0 || o && !ae(o, l.tabbableOptions))
+      if (k(a.activeElement) >= 0)
+        o = a.activeElement;
+      else {
+        var i = n.tabbableGroups[0], f = i && i.firstTabbableNode;
+        o = f || S("fallbackFocus");
+      }
+    else o === null && (o = S("fallbackFocus"));
+    if (!o)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return o;
+  }, R = function() {
+    if (n.containerGroups = n.containers.map(function(o) {
+      var i = Ne(o, l.tabbableOptions), f = Re(o, l.tabbableOptions), g = i.length > 0 ? i[0] : void 0, h = i.length > 0 ? i[i.length - 1] : void 0, T = f.find(function(F) {
+        return U(F);
+      }), v = f.slice().reverse().find(function(F) {
+        return U(F);
+      }), E = !!i.find(function(F) {
+        return q(F) > 0;
+      });
+      return {
+        container: o,
+        tabbableNodes: i,
+        focusableNodes: f,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: E,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: g,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: h,
+        // NOTE: DOM order is NOT NECESSARILY "document position" order, but figuring that out
+        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
+        //  because that API doesn't work with Shadow DOM as well as it should (@see
+        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,
+        //  to address an edge case related to positive tabindex support, this seems like a much easier,
+        //  "close enough most of the time" alternative for positive tabindexes which should generally
+        //  be avoided anyway...
+        /** First tabbable node in container, __DOM__ order; `undefined` if none. */
+        firstDomTabbableNode: T,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: v,
+        /**
+         * Finds the __tabbable__ node that follows the given node in the specified direction,
+         *  in this container, if any.
+         * @param {HTMLElement} node
+         * @param {boolean} [forward] True if going in forward tab order; false if going
+         *  in reverse.
+         * @returns {HTMLElement|undefined} The next tabbable node, if any.
+         */
+        nextTabbableNode: function(P) {
+          var L = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, A = i.indexOf(P);
+          return A < 0 ? L ? f.slice(f.indexOf(P) + 1).find(function(G) {
+            return U(G);
+          }) : f.slice(0, f.indexOf(P)).reverse().find(function(G) {
+            return U(G);
+          }) : i[A + (L ? 1 : -1)];
+        }
+      };
+    }), n.tabbableGroups = n.containerGroups.filter(function(o) {
+      return o.tabbableNodes.length > 0;
+    }), n.tabbableGroups.length <= 0 && !S("fallbackFocus"))
+      throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+    if (n.containerGroups.find(function(o) {
+      return o.posTabIndexesFound;
+    }) && n.containerGroups.length > 1)
+      throw new Error("At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.");
+  }, j = function(o) {
+    var i = o.activeElement;
+    if (i)
+      return i.shadowRoot && i.shadowRoot.activeElement !== null ? j(i.shadowRoot) : i;
+  }, N = function(o) {
+    if (o !== !1 && o !== j(document)) {
+      if (!o || !o.focus) {
+        N(D());
+        return;
+      }
+      o.focus({
+        preventScroll: !!l.preventScroll
+      }), n.mostRecentlyFocusedNode = o, ut(o) && o.select();
+    }
+  }, x = function(o) {
+    var i = S("setReturnFocus", {
+      params: [o]
+    });
+    return i || (i === !1 ? !1 : o);
+  }, I = function(o) {
+    var i = o.target, f = o.event, g = o.isBackward, h = g === void 0 ? !1 : g;
+    i = i || ee(f), R();
+    var T = null;
+    if (n.tabbableGroups.length > 0) {
+      var v = k(i, f), E = v >= 0 ? n.containerGroups[v] : void 0;
+      if (v < 0)
+        h ? T = n.tabbableGroups[n.tabbableGroups.length - 1].lastTabbableNode : T = n.tabbableGroups[0].firstTabbableNode;
+      else if (h) {
+        var F = n.tabbableGroups.findIndex(function(le) {
+          var fe = le.firstTabbableNode;
+          return i === fe;
+        });
+        if (F < 0 && (E.container === i || ae(i, l.tabbableOptions) && !U(i, l.tabbableOptions) && !E.nextTabbableNode(i, !1)) && (F = v), F >= 0) {
+          var P = F === 0 ? n.tabbableGroups.length - 1 : F - 1, L = n.tabbableGroups[P];
+          T = q(i) >= 0 ? L.lastTabbableNode : L.lastDomTabbableNode;
+        } else X(f) || (T = E.nextTabbableNode(i, !1));
+      } else {
+        var A = n.tabbableGroups.findIndex(function(le) {
+          var fe = le.lastTabbableNode;
+          return i === fe;
+        });
+        if (A < 0 && (E.container === i || ae(i, l.tabbableOptions) && !U(i, l.tabbableOptions) && !E.nextTabbableNode(i)) && (A = v), A >= 0) {
+          var G = A === n.tabbableGroups.length - 1 ? 0 : A + 1, K = n.tabbableGroups[G];
+          T = q(i) >= 0 ? K.firstTabbableNode : K.firstDomTabbableNode;
+        } else X(f) || (T = E.nextTabbableNode(i));
+      }
+    } else
+      T = S("fallbackFocus");
+    return T;
+  }, _ = function(o) {
+    var i = ee(o);
+    if (!(k(i, o) >= 0)) {
+      if (Z(l.clickOutsideDeactivates, o)) {
+        p.deactivate({
+          // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,
+          //  which will result in the outside click setting focus to the node
+          //  that was clicked (and if not focusable, to "nothing"); by setting
+          //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused
+          //  on activation (or the configured `setReturnFocus` node), whether the
+          //  outside click was on a focusable node or not
+          returnFocus: l.returnFocusOnDeactivate
+        });
+        return;
+      }
+      Z(l.allowOutsideClick, o) || o.preventDefault();
+    }
+  }, V = function(o) {
+    var i = ee(o), f = k(i, o) >= 0;
+    if (f || i instanceof Document)
+      f && (n.mostRecentlyFocusedNode = i);
+    else {
+      o.stopImmediatePropagation();
+      var g, h = !0;
+      if (n.mostRecentlyFocusedNode)
+        if (q(n.mostRecentlyFocusedNode) > 0) {
+          var T = k(n.mostRecentlyFocusedNode), v = n.containerGroups[T].tabbableNodes;
+          if (v.length > 0) {
+            var E = v.findIndex(function(F) {
+              return F === n.mostRecentlyFocusedNode;
+            });
+            E >= 0 && (l.isKeyForward(n.recentNavEvent) ? E + 1 < v.length && (g = v[E + 1], h = !1) : E - 1 >= 0 && (g = v[E - 1], h = !1));
+          }
+        } else
+          n.containerGroups.some(function(F) {
+            return F.tabbableNodes.some(function(P) {
+              return q(P) > 0;
+            });
+          }) || (h = !1);
+      else
+        h = !1;
+      h && (g = I({
+        // move FROM the MRU node, not event-related node (which will be the node that is
+        //  outside the trap causing the focus escape we're trying to fix)
+        target: n.mostRecentlyFocusedNode,
+        isBackward: l.isKeyBackward(n.recentNavEvent)
+      })), N(g || n.mostRecentlyFocusedNode || D());
+    }
+    n.recentNavEvent = void 0;
+  }, z = function(o) {
+    var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    n.recentNavEvent = o;
+    var f = I({
+      event: o,
+      isBackward: i
+    });
+    f && (X(o) && o.preventDefault(), N(f));
+  }, $ = function(o) {
+    (l.isKeyForward(o) || l.isKeyBackward(o)) && z(o, l.isKeyBackward(o));
+  }, Y = function(o) {
+    st(o) && Z(l.escapeDeactivates, o) !== !1 && (o.preventDefault(), p.deactivate());
+  }, M = function(o) {
+    var i = ee(o);
+    k(i, o) >= 0 || Z(l.clickOutsideDeactivates, o) || Z(l.allowOutsideClick, o) || (o.preventDefault(), o.stopImmediatePropagation());
+  }, d = function() {
+    if (n.active)
+      return B.activateTrap(u, p), n.delayInitialFocusTimer = l.delayInitialFocus ? ge(function() {
+        N(D());
+      }) : N(D()), a.addEventListener("focusin", V, !0), a.addEventListener("mousedown", _, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("touchstart", _, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("click", M, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", $, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", Y), p;
+  }, s = function(o) {
+    n.active && !n.paused && p._setSubtreeIsolation(!1), n.adjacentElements.clear(), n.alreadySilent.clear();
+    var i = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), g = he(o), h;
+    try {
+      for (g.s(); !(h = g.n()).done; ) {
+        var T = h.value;
+        i.add(T);
+        for (var v = typeof ShadowRoot < "u" && T.getRootNode() instanceof ShadowRoot, E = T; E; ) {
+          i.add(E);
+          var F = E.parentElement, P = [];
+          F ? P = F.children : !F && v && (P = E.getRootNode().children, F = E.getRootNode().host, v = typeof ShadowRoot < "u" && F.getRootNode() instanceof ShadowRoot);
+          var L = he(P), A;
+          try {
+            for (L.s(); !(A = L.n()).done; ) {
+              var G = A.value;
+              f.add(G);
+            }
+          } catch (K) {
+            L.e(K);
+          } finally {
+            L.f();
+          }
+          E = F;
+        }
+      }
+    } catch (K) {
+      g.e(K);
+    } finally {
+      g.f();
+    }
+    i.forEach(function(K) {
+      f.delete(K);
+    }), n.adjacentElements = f;
+  }, m = function() {
+    if (n.active)
+      return a.removeEventListener("focusin", V, !0), a.removeEventListener("mousedown", _, !0), a.removeEventListener("touchstart", _, !0), a.removeEventListener("click", M, !0), a.removeEventListener("keydown", $, !0), a.removeEventListener("keydown", Y), p;
+  }, c = function(o) {
+    var i = o.some(function(f) {
+      var g = Array.from(f.removedNodes);
+      return g.some(function(h) {
+        return h === n.mostRecentlyFocusedNode;
+      });
+    });
+    i && N(D());
+  }, w = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(c) : void 0, O = function() {
+    w && (w.disconnect(), n.active && !n.paused && n.containers.map(function(o) {
+      w.observe(o, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return p = {
+    get active() {
+      return n.active;
+    },
+    get paused() {
+      return n.paused;
+    },
+    activate: function(o) {
+      if (n.active)
+        return this;
+      var i = y(o, "onActivate"), f = y(o, "onPostActivate"), g = y(o, "checkCanFocusTrap"), h = B.getActiveTrap(u), T = !1;
+      if (h && !h.paused) {
+        var v;
+        (v = h._setSubtreeIsolation) === null || v === void 0 || v.call(h, !1), T = !0;
+      }
+      try {
+        g || R(), n.active = !0, n.paused = !1, n.nodeFocusedBeforeActivation = j(a), i == null || i();
+        var E = function() {
+          g && R(), d(), O(), l.isolateSubtrees && p._setSubtreeIsolation(!0), f == null || f();
+        };
+        if (g)
+          return g(n.containers.concat()).then(E, E), this;
+        E();
+      } catch (P) {
+        if (h === B.getActiveTrap(u) && T) {
+          var F;
+          (F = h._setSubtreeIsolation) === null || F === void 0 || F.call(h, !0);
+        }
+        throw P;
+      }
+      return this;
+    },
+    deactivate: function(o) {
+      if (!n.active)
+        return this;
+      var i = me({
+        onDeactivate: l.onDeactivate,
+        onPostDeactivate: l.onPostDeactivate,
+        checkCanReturnFocus: l.checkCanReturnFocus
+      }, o);
+      clearTimeout(n.delayInitialFocusTimer), n.delayInitialFocusTimer = void 0, n.paused || p._setSubtreeIsolation(!1), n.alreadySilent.clear(), m(), n.active = !1, n.paused = !1, O(), B.deactivateTrap(u, p);
+      var f = y(i, "onDeactivate"), g = y(i, "onPostDeactivate"), h = y(i, "checkCanReturnFocus"), T = y(i, "returnFocus", "returnFocusOnDeactivate");
+      f == null || f();
+      var v = function() {
+        ge(function() {
+          T && N(x(n.nodeFocusedBeforeActivation)), g == null || g();
+        });
+      };
+      return T && h ? (h(x(n.nodeFocusedBeforeActivation)).then(v, v), this) : (v(), this);
+    },
+    pause: function(o) {
+      return n.active ? (n.manuallyPaused = !0, this._setPausedState(!0, o)) : this;
+    },
+    unpause: function(o) {
+      return n.active ? (n.manuallyPaused = !1, u[u.length - 1] !== this ? this : this._setPausedState(!1, o)) : this;
+    },
+    updateContainerElements: function(o) {
+      var i = [].concat(o).filter(Boolean);
+      return n.containers = i.map(function(f) {
+        return typeof f == "string" ? a.querySelector(f) : f;
+      }), l.isolateSubtrees && s(n.containers), n.active && (R(), l.isolateSubtrees && !n.paused && p._setSubtreeIsolation(!0)), O(), this;
+    }
+  }, Object.defineProperties(p, {
+    _isManuallyPaused: {
+      value: function() {
+        return n.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(o, i) {
+        if (n.paused === o)
+          return this;
+        if (n.paused = o, o) {
+          var f = y(i, "onPause"), g = y(i, "onPostPause");
+          f == null || f(), m(), O(), p._setSubtreeIsolation(!1), g == null || g();
+        } else {
+          var h = y(i, "onUnpause"), T = y(i, "onPostUnpause");
+          h == null || h(), p._setSubtreeIsolation(!0), R(), d(), O(), T == null || T();
+        }
+        return this;
+      }
+    },
+    _setSubtreeIsolation: {
+      value: function(o) {
+        l.isolateSubtrees && n.adjacentElements.forEach(function(i) {
+          var f;
+          if (o)
+            switch (l.isolateSubtrees) {
+              case "aria-hidden":
+                (i.ariaHidden === "true" || ((f = i.getAttribute("aria-hidden")) === null || f === void 0 ? void 0 : f.toLowerCase()) === "true") && n.alreadySilent.add(i), i.setAttribute("aria-hidden", "true");
+                break;
+              default:
+                (i.inert || i.hasAttribute("inert")) && n.alreadySilent.add(i), i.setAttribute("inert", !0);
+                break;
+            }
+          else if (!n.alreadySilent.has(i)) switch (l.isolateSubtrees) {
+            case "aria-hidden":
+              i.removeAttribute("aria-hidden");
+              break;
+            default:
+              i.removeAttribute("inert");
+              break;
+          }
+        });
+      }
+    }
+  }), p.updateContainerElements(e), p;
+};
+const vt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createFocusTrap: dt
+}, Symbol.toStringTag, { value: "Module" })), pt = /* @__PURE__ */ we(vt), bt = /* @__PURE__ */ we(Qe);
+var Te;
+function ht() {
+  if (Te) return Q.exports;
+  Te = 1;
+  function r(d) {
+    "@babel/helpers - typeof";
+    return r = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(s) {
+      return typeof s;
+    } : function(s) {
+      return s && typeof Symbol == "function" && s.constructor === Symbol && s !== Symbol.prototype ? "symbol" : typeof s;
+    }, r(d);
+  }
+  var e, t;
+  function a(d, s) {
+    if (!(d instanceof s)) throw new TypeError("Cannot call a class as a function");
+  }
+  function u(d, s) {
+    for (var m = 0; m < s.length; m++) {
+      var c = s[m];
+      c.enumerable = c.enumerable || !1, c.configurable = !0, "value" in c && (c.writable = !0), Object.defineProperty(d, N(c.key), c);
+    }
+  }
+  function l(d, s, m) {
+    return s && u(d.prototype, s), Object.defineProperty(d, "prototype", { writable: !1 }), d;
+  }
+  function n(d, s, m) {
+    return s = S(s), p(d, k() ? Reflect.construct(s, m || [], S(d).constructor) : s.apply(d, m));
+  }
+  function p(d, s) {
+    if (s && (r(s) == "object" || typeof s == "function")) return s;
+    if (s !== void 0) throw new TypeError("Derived constructors may only return object or undefined");
+    return y(d);
+  }
+  function y(d) {
+    if (d === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return d;
+  }
+  function k() {
+    try {
+      var d = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      }));
+    } catch {
+    }
+    return (k = function() {
+      return !!d;
+    })();
+  }
+  function S(d) {
+    return S = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(s) {
+      return s.__proto__ || Object.getPrototypeOf(s);
+    }, S(d);
+  }
+  function D(d, s) {
+    if (typeof s != "function" && s !== null) throw new TypeError("Super expression must either be null or a function");
+    d.prototype = Object.create(s && s.prototype, { constructor: { value: d, writable: !0, configurable: !0 } }), Object.defineProperty(d, "prototype", { writable: !1 }), s && R(d, s);
+  }
+  function R(d, s) {
+    return R = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(m, c) {
+      return m.__proto__ = c, m;
+    }, R(d, s);
+  }
+  function j(d, s, m) {
+    return (s = N(s)) in d ? Object.defineProperty(d, s, { value: m, enumerable: !0, configurable: !0, writable: !0 }) : d[s] = m, d;
+  }
+  function N(d) {
+    var s = x(d, "string");
+    return r(s) == "symbol" ? s : s + "";
+  }
+  function x(d, s) {
+    if (r(d) != "object" || !d) return d;
+    var m = d[Symbol.toPrimitive];
+    if (m !== void 0) {
+      var c = m.call(d, s);
+      if (r(c) != "object") return c;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (s === "string" ? String : Number)(d);
+  }
+  var I = Ie, _ = pt, V = _.createFocusTrap, z = bt, $ = z.isFocusable, Y = parseInt((e = (t = /^(\d+)\./.exec(I.version)) === null || t === void 0 ? void 0 : t[1]) !== null && e !== void 0 ? e : 0, 10), M = /* @__PURE__ */ (function(d) {
+    function s(m) {
+      var c;
+      a(this, s), c = n(this, s, [m]), j(c, "getNodeForOption", function(b) {
+        var o, i = (o = this.internalOptions[b]) !== null && o !== void 0 ? o : this.originalOptions[b];
+        if (typeof i == "function") {
+          for (var f = arguments.length, g = new Array(f > 1 ? f - 1 : 0), h = 1; h < f; h++)
+            g[h - 1] = arguments[h];
+          i = i.apply(void 0, g);
+        }
+        if (i === !0 && (i = void 0), !i) {
+          if (i === void 0 || i === !1)
+            return i;
+          throw new Error("`".concat(b, "` was specified but was not a node, or did not return a node"));
+        }
+        var T = i;
+        if (typeof i == "string") {
+          var v;
+          if (T = (v = this.getDocument()) === null || v === void 0 ? void 0 : v.querySelector(i), !T)
+            throw new Error("`".concat(b, "` as selector refers to no known node"));
+        }
+        return T;
+      }), c.handleDeactivate = c.handleDeactivate.bind(c), c.handlePostDeactivate = c.handlePostDeactivate.bind(c), c.handleClickOutsideDeactivates = c.handleClickOutsideDeactivates.bind(c), c.internalOptions = {
+        // We need to hijack the returnFocusOnDeactivate option,
+        // because React can move focus into the element before we arrived at
+        // this lifecycle hook (e.g. with autoFocus inputs). So the component
+        // captures the previouslyFocusedElement in componentWillMount,
+        // then (optionally) returns focus to it in componentWillUnmount.
+        returnFocusOnDeactivate: !1,
+        // the rest of these are also related to deactivation of the trap, and we
+        //  need to use them and control them as well
+        checkCanReturnFocus: null,
+        onDeactivate: c.handleDeactivate,
+        onPostDeactivate: c.handlePostDeactivate,
+        // we need to special-case this setting as well so that we can know if we should
+        //  NOT return focus if the trap gets auto-deactivated as the result of an
+        //  outside click (otherwise, we'll always think we should return focus because
+        //  of how we manage that flag internally here)
+        clickOutsideDeactivates: c.handleClickOutsideDeactivates
+      }, c.originalOptions = {
+        // because of the above `internalOptions`, we maintain our own flag for
+        //  this option, and default it to `true` because that's focus-trap's default
+        returnFocusOnDeactivate: !0,
+        // because of the above `internalOptions`, we keep these separate since
+        //  they're part of the deactivation process which we configure (internally) to
+        //  be shared between focus-trap and focus-trap-react
+        onDeactivate: null,
+        onPostDeactivate: null,
+        checkCanReturnFocus: null,
+        // the user's setting, defaulted to false since focus-trap defaults this to false
+        clickOutsideDeactivates: !1
+      };
+      var w = m.focusTrapOptions;
+      for (var O in w)
+        if (Object.prototype.hasOwnProperty.call(w, O)) {
+          if (O === "returnFocusOnDeactivate" || O === "onDeactivate" || O === "onPostDeactivate" || O === "checkCanReturnFocus" || O === "clickOutsideDeactivates") {
+            c.originalOptions[O] = w[O];
+            continue;
+          }
+          c.internalOptions[O] = w[O];
+        }
+      return c.outsideClick = null, c.focusTrapElements = m.containerElements || [], c.updatePreviousElement(), c;
+    }
+    return D(s, d), l(s, [{
+      key: "getDocument",
+      value: function() {
+        return this.props.focusTrapOptions.document || (typeof document < "u" ? document : void 0);
+      }
+    }, {
+      key: "getReturnFocusNode",
+      value: function() {
+        var c = this.getNodeForOption("setReturnFocus", this.previouslyFocusedElement);
+        return c || (c === !1 ? !1 : this.previouslyFocusedElement);
+      }
+      /** Update the previously focused element with the currently focused element. */
+    }, {
+      key: "updatePreviousElement",
+      value: function() {
+        var c = this.getDocument();
+        c && (this.previouslyFocusedElement = c.activeElement);
+      }
+    }, {
+      key: "deactivateTrap",
+      value: function() {
+        !this.focusTrap || !this.focusTrap.active || this.focusTrap.deactivate({
+          // NOTE: we never let the trap return the focus since we do that ourselves
+          returnFocus: !1,
+          // we'll call this in our own post deactivate handler so make sure the trap doesn't
+          //  do it prematurely
+          checkCanReturnFocus: null,
+          // let it call the user's original deactivate handler, if any, instead of
+          //  our own which calls back into this function
+          onDeactivate: this.originalOptions.onDeactivate
+          // NOTE: for post deactivate, don't specify anything so that it calls the
+          //  onPostDeactivate handler specified on `this.internalOptions`
+          //  which will always be our own `handlePostDeactivate()` handler, which
+          //  will finish things off by calling the user's provided onPostDeactivate
+          //  handler, if any, at the right time
+          // onPostDeactivate: NOTHING
+        });
+      }
+    }, {
+      key: "handleClickOutsideDeactivates",
+      value: function(c) {
+        var w = typeof this.originalOptions.clickOutsideDeactivates == "function" ? this.originalOptions.clickOutsideDeactivates.call(null, c) : this.originalOptions.clickOutsideDeactivates;
+        return w && (this.outsideClick = {
+          target: c.target,
+          allowDeactivation: w
+        }), w;
+      }
+    }, {
+      key: "handleDeactivate",
+      value: function() {
+        this.originalOptions.onDeactivate && this.originalOptions.onDeactivate.call(null), this.deactivateTrap();
+      }
+    }, {
+      key: "handlePostDeactivate",
+      value: function() {
+        var c = this, w = function() {
+          var b = c.getReturnFocusNode(), o = !!// did the consumer allow it?
+          (c.originalOptions.returnFocusOnDeactivate && // can we actually focus the node?
+          b !== null && b !== void 0 && b.focus && // was there an outside click that allowed deactivation?
+          (!c.outsideClick || // did the consumer allow deactivation when the outside node was clicked?
+          c.outsideClick.allowDeactivation && // is the outside node NOT focusable (implying that it did NOT receive focus
+          //  as a result of the click-through) -- in which case do NOT restore focus
+          //  to `returnFocusNode` because focus should remain on the outside node
+          !$(c.outsideClick.target, c.internalOptions.tabbableOptions))), i = c.internalOptions.preventScroll, f = i === void 0 ? !1 : i;
+          o && b.focus({
+            preventScroll: f
+          }), c.originalOptions.onPostDeactivate && c.originalOptions.onPostDeactivate.call(null), c.outsideClick = null;
+        };
+        this.originalOptions.checkCanReturnFocus ? this.originalOptions.checkCanReturnFocus.call(null, this.getReturnFocusNode()).then(w, w) : w();
+      }
+    }, {
+      key: "setupFocusTrap",
+      value: function() {
+        if (this.focusTrap)
+          this.props.active && !this.focusTrap.active && (this.focusTrap.activate(), this.props.paused && this.focusTrap.pause());
+        else {
+          var c = this.focusTrapElements.some(Boolean);
+          c && (this.focusTrap = this.props._createFocusTrap(this.focusTrapElements, this.internalOptions), this.props.active && this.focusTrap.activate(), this.props.paused && this.focusTrap.pause());
+        }
+      }
+    }, {
+      key: "componentDidMount",
+      value: function() {
+        this.props.active && this.setupFocusTrap();
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function(c) {
+        if (this.focusTrap) {
+          c.containerElements !== this.props.containerElements && this.focusTrap.updateContainerElements(this.props.containerElements);
+          var w = !c.active && this.props.active, O = c.active && !this.props.active, b = !c.paused && this.props.paused, o = c.paused && !this.props.paused;
+          if (w && (this.updatePreviousElement(), this.focusTrap.activate()), O) {
+            this.deactivateTrap();
+            return;
+          }
+          b && this.focusTrap.pause(), o && this.focusTrap.unpause();
+        } else
+          c.containerElements !== this.props.containerElements && (this.focusTrapElements = this.props.containerElements), this.props.active && (this.updatePreviousElement(), this.setupFocusTrap());
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function() {
+        this.deactivateTrap();
+      }
+    }, {
+      key: "render",
+      value: function() {
+        var c = this, w = this.props.children ? I.Children.only(this.props.children) : void 0;
+        if (w) {
+          if (w.type && w.type === I.Fragment)
+            throw new Error("A focus-trap cannot use a Fragment as its child container. Try replacing it with a <div> element.");
+          var O = function(i) {
+            var f = c.props.containerElements;
+            w && (Y >= 19 ? typeof w.props.ref == "function" ? w.props.ref(i) : w.props.ref && (w.props.ref.current = i) : typeof w.ref == "function" ? w.ref(i) : w.ref && (w.ref.current = i)), c.focusTrapElements = f || [i];
+          }, b = I.cloneElement(w, {
+            ref: O
+          });
+          return b;
+        }
+        return null;
+      }
+    }]);
+  })(I.Component);
+  return M.defaultProps = {
+    active: !0,
+    paused: !1,
+    focusTrapOptions: {},
+    _createFocusTrap: V
+  }, Q.exports = M, Q.exports.FocusTrap = M, Q.exports;
+}
+var yt = ht();
+const Ce = Ae({
+  isVisible: !1
+}), {
+  Provider: mt
+} = Ce;
+function gt() {
+  return je(Ce);
+}
+function Tt() {
+  const {
+    close: r
+  } = gt(), e = J(() => {
+    r == null || r();
+  }, [r]);
+  return /* @__PURE__ */ C.jsxs(C.Fragment, { children: [
+    /* @__PURE__ */ C.jsx("div", { className: "kakadu-components-2543813221" }),
+    /* @__PURE__ */ C.jsx("div", { className: "kakadu-components-840864829", children: /* @__PURE__ */ C.jsx(Be, { icon: _e.times, label: "Close", className: "kakadu-components-3855719072", onClick: e }) })
+  ] });
+}
+function Nt({
+  root: r,
+  maxWidth: e,
+  className: t,
+  isVisible: a,
+  isFullWidth: u = !1,
+  shouldCloseOnOutsideClick: l = !0,
+  shouldCloseOnEscapePress: n = !0,
+  showCloseButton: p = !0,
+  onClose: y,
+  children: k
+}) {
+  const S = te(null), D = te(null), [R, j] = re(!1), [N, x] = re(!1), I = J((s) => {
+    S.current = s, x(!1);
+  }, []), _ = te(null), V = J((s) => {
+    s && (_.current = s);
+  }, []), [z, $] = re(a ?? !1), Y = ne(() => ({
+    isVisible: z,
+    setInitialFocus: V,
+    close: I
+  }), [z, V, I]);
+  H(() => {
+    a && (j(!0), $(!0));
+  }, [a]), H(() => {
+    if (a) {
+      const s = setTimeout(() => {
+        x(!0);
+      }, 100);
+      return () => {
+        clearTimeout(s);
+      };
+    }
+    x(!1);
+  }, [a]), H(() => {
+    if (R && !N) {
+      const s = setTimeout(() => {
+        y == null || y(S.current ?? void 0), $(!1);
+      }, 370);
+      return () => {
+        clearTimeout(s);
+      };
+    }
+  }, [R, N, y]), H(() => {
+    const s = D.current;
+    if (a && l && s) {
+      const m = (c) => {
+        s === c.target && x(!1);
+      };
+      return s.addEventListener("click", m), () => {
+        s.removeEventListener("click", m);
+      };
+    }
+  }, [a, l]), H(() => {
+    if (!a || !n)
+      return;
+    const s = (m) => {
+      m.key === "Escape" && x(!1);
+    };
+    return window.addEventListener("keydown", s), () => {
+      window.removeEventListener("keydown", s);
+    };
+  }, [a, n]);
+  const M = ne(() => ({
+    initialFocus: () => _.current ?? void 0,
+    onActivate: () => {
+      var s;
+      return (s = _.current) == null ? void 0 : s.focus();
+    }
+  }), []), d = /* @__PURE__ */ C.jsx("div", { style: {
+    "--max-width": e ? `${e}px` : void 0
+  }, className: pe(r ? Le : void 0, "kakadu-components-2807459246", N && "kakadu-components-1399012551", t), children: /* @__PURE__ */ C.jsx(yt.FocusTrap, { active: N, focusTrapOptions: M, children: /* @__PURE__ */ C.jsx("div", { ref: D, className: "kakadu-components-3521538255", children: /* @__PURE__ */ C.jsx("div", { className: pe("kakadu-components-1982320206", u && "kakadu-components-3904045733", N && "kakadu-components-3829535111"), children: /* @__PURE__ */ C.jsxs(mt, { value: Y, children: [
+    p ? /* @__PURE__ */ C.jsx(Tt, {}) : null,
+    /* @__PURE__ */ C.jsx("div", { className: "kakadu-components-2617708556", children: k })
+  ] }) }) }) }) });
+  return r ? xe(d, r) : d;
+}
+function Rt(r, e) {
+  const [t, a] = re(!1), u = te(void 0), l = J(async () => (a(!0), new Promise((y) => {
+    u.current = y;
+  })), []), n = J((y) => {
+    var k;
+    a(!1), (k = u.current) == null || k.call(u, y), u.current = void 0;
+  }, []), p = ne(() => /* @__PURE__ */ C.jsx(r, { ...e, isVisible: t, onClose: n }), [r, e, t, n]);
+  return ne(() => ({
+    isVisible: t,
+    show: l,
+    modal: p
+  }), [t, l, p]);
+}
+export {
+  Nt as default,
+  Rt as useModal,
+  gt as useModalContext
+};