agnosticui-core 2.0.0-alpha.2

package/dist/components/Dialog/core/_dialog.js

@@ -0,0 +1,1003 @@
+import { LitElement as ke, css as Te, nothing as X, html as j } from "lit";
+import { n as E } from "../../../property-CemaeiRl.js";
+import { isBackdropClick as Ee } from "../../../utils/handleBackdropClick.js";
+import { isElementInContainer as Ne } from "../../../utils/isElementInContainer.js";
+import "../../shared/CloseButton/CloseButton.js";
+/*!
+* tabbable 6.2.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var ve = ["input:not([inert])", "select:not([inert])", "textarea:not([inert])", "a[href]:not([inert])", "button:not([inert])", "[tabindex]:not(slot):not([inert])", "audio[controls]:not([inert])", "video[controls]:not([inert])", '[contenteditable]:not([contenteditable="false"]):not([inert])', "details>summary:first-of-type:not([inert])", "details:not([inert])"], M = /* @__PURE__ */ ve.join(","), be = typeof Element > "u", O = be ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, $ = !be && Element.prototype.getRootNode ? function(i) {
+  var e;
+  return i == null || (e = i.getRootNode) === null || e === void 0 ? void 0 : e.call(i);
+} : function(i) {
+  return i?.ownerDocument;
+}, G = function i(e, t) {
+  var a;
+  t === void 0 && (t = !0);
+  var s = e == null || (a = e.getAttribute) === null || a === void 0 ? void 0 : a.call(e, "inert"), l = s === "" || s === "true", r = l || t && e && i(e.parentNode);
+  return r;
+}, Ce = function(e) {
+  var t, a = e == null || (t = e.getAttribute) === null || t === void 0 ? void 0 : t.call(e, "contenteditable");
+  return a === "" || a === "true";
+}, pe = function(e, t, a) {
+  if (G(e))
+    return [];
+  var s = Array.prototype.slice.apply(e.querySelectorAll(M));
+  return t && O.call(e, M) && s.unshift(e), s = s.filter(a), s;
+}, he = function i(e, t, a) {
+  for (var s = [], l = Array.from(e); l.length; ) {
+    var r = l.shift();
+    if (!G(r, !1))
+      if (r.tagName === "SLOT") {
+        var b = r.assignedElements(), v = b.length ? b : r.children, g = i(v, !0, a);
+        a.flatten ? s.push.apply(s, g) : s.push({
+          scopeParent: r,
+          candidates: g
+        });
+      } else {
+        var k = O.call(r, M);
+        k && a.filter(r) && (t || !e.includes(r)) && s.push(r);
+        var w = r.shadowRoot || // check for an undisclosed shadow
+        typeof a.getShadowRoot == "function" && a.getShadowRoot(r), S = !G(w, !1) && (!a.shadowRootFilter || a.shadowRootFilter(r));
+        if (w && S) {
+          var R = i(w === !0 ? r.children : w.children, !0, a);
+          a.flatten ? s.push.apply(s, R) : s.push({
+            scopeParent: r,
+            candidates: R
+          });
+        } else
+          l.unshift.apply(l, r.children);
+      }
+  }
+  return s;
+}, ge = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, A = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || Ce(e)) && !ge(e) ? 0 : e.tabIndex;
+}, Fe = function(e, t) {
+  var a = A(e);
+  return a < 0 && t && !ge(e) ? 0 : a;
+}, Se = function(e, t) {
+  return e.tabIndex === t.tabIndex ? e.documentOrder - t.documentOrder : e.tabIndex - t.tabIndex;
+}, me = function(e) {
+  return e.tagName === "INPUT";
+}, De = function(e) {
+  return me(e) && e.type === "hidden";
+}, Ae = function(e) {
+  var t = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(a) {
+    return a.tagName === "SUMMARY";
+  });
+  return t;
+}, Oe = function(e, t) {
+  for (var a = 0; a < e.length; a++)
+    if (e[a].checked && e[a].form === t)
+      return e[a];
+}, Re = function(e) {
+  if (!e.name)
+    return !0;
+  var t = e.form || $(e), a = function(b) {
+    return t.querySelectorAll('input[type="radio"][name="' + b + '"]');
+  }, s;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    s = a(window.CSS.escape(e.name));
+  else
+    try {
+      s = a(e.name);
+    } catch (r) {
+      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", r.message), !1;
+    }
+  var l = Oe(s, e.form);
+  return !l || l === e;
+}, Pe = function(e) {
+  return me(e) && e.type === "radio";
+}, Ie = function(e) {
+  return Pe(e) && !Re(e);
+}, xe = function(e) {
+  var t, a = e && $(e), s = (t = a) === null || t === void 0 ? void 0 : t.host, l = !1;
+  if (a && a !== e) {
+    var r, b, v;
+    for (l = !!((r = s) !== null && r !== void 0 && (b = r.ownerDocument) !== null && b !== void 0 && b.contains(s) || e != null && (v = e.ownerDocument) !== null && v !== void 0 && v.contains(e)); !l && s; ) {
+      var g, k, w;
+      a = $(s), s = (g = a) === null || g === void 0 ? void 0 : g.host, l = !!((k = s) !== null && k !== void 0 && (w = k.ownerDocument) !== null && w !== void 0 && w.contains(s));
+    }
+  }
+  return l;
+}, le = function(e) {
+  var t = e.getBoundingClientRect(), a = t.width, s = t.height;
+  return a === 0 && s === 0;
+}, Be = function(e, t) {
+  var a = t.displayCheck, s = t.getShadowRoot;
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var l = O.call(e, "details>summary:first-of-type"), r = l ? e.parentElement : e;
+  if (O.call(r, "details:not([open]) *"))
+    return !0;
+  if (!a || a === "full" || a === "legacy-full") {
+    if (typeof s == "function") {
+      for (var b = e; e; ) {
+        var v = e.parentElement, g = $(e);
+        if (v && !v.shadowRoot && s(v) === !0)
+          return le(e);
+        e.assignedSlot ? e = e.assignedSlot : !v && g !== e.ownerDocument ? e = g.host : e = v;
+      }
+      e = b;
+    }
+    if (xe(e))
+      return !e.getClientRects().length;
+    if (a !== "legacy-full")
+      return !0;
+  } else if (a === "non-zero-area")
+    return le(e);
+  return !1;
+}, Le = 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 s = t.children.item(a);
+          if (s.tagName === "LEGEND")
+            return O.call(t, "fieldset[disabled] *") ? !0 : !s.contains(e);
+        }
+        return !0;
+      }
+      t = t.parentElement;
+    }
+  return !1;
+}, q = function(e, t) {
+  return !(t.disabled || // we must do an inert look up to filter out any elements inside an inert ancestor
+  //  because we're limited in the type of selectors we can use in JSDom (see related
+  //  note related to `candidateSelectors`)
+  G(t) || De(t) || Be(t, e) || // For a details element with a summary, the summary element gets the focus
+  Ae(t) || Le(t));
+}, H = function(e, t) {
+  return !(Ie(t) || A(t) < 0 || !q(e, t));
+}, _e = function(e) {
+  var t = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(t) || t >= 0);
+}, Ke = function i(e) {
+  var t = [], a = [];
+  return e.forEach(function(s, l) {
+    var r = !!s.scopeParent, b = r ? s.scopeParent : s, v = Fe(b, r), g = r ? i(s.candidates) : b;
+    v === 0 ? r ? t.push.apply(t, g) : t.push(b) : a.push({
+      documentOrder: l,
+      tabIndex: v,
+      item: s,
+      isScope: r,
+      content: g
+    });
+  }), a.sort(Se).reduce(function(s, l) {
+    return l.isScope ? s.push.apply(s, l.content) : s.push(l.content), s;
+  }, []).concat(t);
+}, je = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = he([e], t.includeContainer, {
+    filter: H.bind(null, t),
+    flatten: !1,
+    getShadowRoot: t.getShadowRoot,
+    shadowRootFilter: _e
+  }) : a = pe(e, t.includeContainer, H.bind(null, t)), Ke(a);
+}, ze = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = he([e], t.includeContainer, {
+    filter: q.bind(null, t),
+    flatten: !0,
+    getShadowRoot: t.getShadowRoot
+  }) : a = pe(e, t.includeContainer, q.bind(null, t)), a;
+}, P = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return O.call(e, M) === !1 ? !1 : H(t, e);
+}, Me = /* @__PURE__ */ ve.concat("iframe").join(","), W = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return O.call(e, Me) === !1 ? !1 : q(t, e);
+};
+/*!
+* focus-trap 7.6.5
+* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+*/
+function Z(i, e) {
+  (e == null || e > i.length) && (e = i.length);
+  for (var t = 0, a = Array(e); t < e; t++) a[t] = i[t];
+  return a;
+}
+function $e(i) {
+  if (Array.isArray(i)) return Z(i);
+}
+function Ge(i, e, t) {
+  return (e = Xe(e)) in i ? Object.defineProperty(i, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : i[e] = t, i;
+}
+function qe(i) {
+  if (typeof Symbol < "u" && i[Symbol.iterator] != null || i["@@iterator"] != null) return Array.from(i);
+}
+function Ye() {
+  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 ce(i, e) {
+  var t = Object.keys(i);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(i);
+    e && (a = a.filter(function(s) {
+      return Object.getOwnPropertyDescriptor(i, s).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function ue(i) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? ce(Object(t), !0).forEach(function(a) {
+      Ge(i, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(i, Object.getOwnPropertyDescriptors(t)) : ce(Object(t)).forEach(function(a) {
+      Object.defineProperty(i, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return i;
+}
+function Ue(i) {
+  return $e(i) || qe(i) || We(i) || Ye();
+}
+function Ve(i, e) {
+  if (typeof i != "object" || !i) return i;
+  var t = i[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var a = t.call(i, e);
+    if (typeof a != "object") return a;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(i);
+}
+function Xe(i) {
+  var e = Ve(i, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function We(i, e) {
+  if (i) {
+    if (typeof i == "string") return Z(i, e);
+    var t = {}.toString.call(i).slice(8, -1);
+    return t === "Object" && i.constructor && (t = i.constructor.name), t === "Map" || t === "Set" ? Array.from(i) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? Z(i, e) : void 0;
+  }
+}
+var de = {
+  activateTrap: function(e, t) {
+    if (e.length > 0) {
+      var a = e[e.length - 1];
+      a !== t && a._setPausedState(!0);
+    }
+    var s = e.indexOf(t);
+    s === -1 || e.splice(s, 1), e.push(t);
+  },
+  deactivateTrap: function(e, t) {
+    var a = e.indexOf(t);
+    a !== -1 && e.splice(a, 1), e.length > 0 && !e[e.length - 1]._isManuallyPaused() && e[e.length - 1]._setPausedState(!1);
+  }
+}, He = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, Ze = function(e) {
+  return e?.key === "Escape" || e?.key === "Esc" || e?.keyCode === 27;
+}, _ = function(e) {
+  return e?.key === "Tab" || e?.keyCode === 9;
+}, Je = function(e) {
+  return _(e) && !e.shiftKey;
+}, Qe = function(e) {
+  return _(e) && e.shiftKey;
+}, fe = function(e) {
+  return setTimeout(e, 0);
+}, L = function(e) {
+  for (var t = arguments.length, a = new Array(t > 1 ? t - 1 : 0), s = 1; s < t; s++)
+    a[s - 1] = arguments[s];
+  return typeof e == "function" ? e.apply(void 0, a) : e;
+}, z = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, et = [], tt = function(e, t) {
+  var a = t?.document || document, s = t?.trapStack || et, l = ue({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isKeyForward: Je,
+    isKeyBackward: Qe
+  }, t), r = {
+    // 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: [],
+    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
+  }, b, v = function(n, o, c) {
+    return n && n[o] !== void 0 ? n[o] : l[c || o];
+  }, g = function(n, o) {
+    var c = typeof o?.composedPath == "function" ? o.composedPath() : void 0;
+    return r.containerGroups.findIndex(function(d) {
+      var f = d.container, h = d.tabbableNodes;
+      return f.contains(n) || c?.includes(f) || h.find(function(u) {
+        return u === n;
+      });
+    });
+  }, k = function(n) {
+    var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, c = o.hasFallback, d = c === void 0 ? !1 : c, f = o.params, h = f === void 0 ? [] : f, u = l[n];
+    if (typeof u == "function" && (u = u.apply(void 0, Ue(h))), u === !0 && (u = void 0), !u) {
+      if (u === void 0 || u === !1)
+        return u;
+      throw new Error("`".concat(n, "` was specified but was not a node, or did not return a node"));
+    }
+    var m = u;
+    if (typeof u == "string") {
+      try {
+        m = a.querySelector(u);
+      } catch (y) {
+        throw new Error("`".concat(n, '` appears to be an invalid selector; error="').concat(y.message, '"'));
+      }
+      if (!m && !d)
+        throw new Error("`".concat(n, "` as selector refers to no known node"));
+    }
+    return m;
+  }, w = function() {
+    var n = k("initialFocus", {
+      hasFallback: !0
+    });
+    if (n === !1)
+      return !1;
+    if (n === void 0 || n && !W(n, l.tabbableOptions))
+      if (g(a.activeElement) >= 0)
+        n = a.activeElement;
+      else {
+        var o = r.tabbableGroups[0], c = o && o.firstTabbableNode;
+        n = c || k("fallbackFocus");
+      }
+    else n === null && (n = k("fallbackFocus"));
+    if (!n)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return n;
+  }, S = function() {
+    if (r.containerGroups = r.containers.map(function(n) {
+      var o = je(n, l.tabbableOptions), c = ze(n, l.tabbableOptions), d = o.length > 0 ? o[0] : void 0, f = o.length > 0 ? o[o.length - 1] : void 0, h = c.find(function(y) {
+        return P(y);
+      }), u = c.slice().reverse().find(function(y) {
+        return P(y);
+      }), m = !!o.find(function(y) {
+        return A(y) > 0;
+      });
+      return {
+        container: n,
+        tabbableNodes: o,
+        focusableNodes: c,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: m,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: d,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: f,
+        // 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: h,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: u,
+        /**
+         * 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(D) {
+          var x = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, F = o.indexOf(D);
+          return F < 0 ? x ? c.slice(c.indexOf(D) + 1).find(function(B) {
+            return P(B);
+          }) : c.slice(0, c.indexOf(D)).reverse().find(function(B) {
+            return P(B);
+          }) : o[F + (x ? 1 : -1)];
+        }
+      };
+    }), r.tabbableGroups = r.containerGroups.filter(function(n) {
+      return n.tabbableNodes.length > 0;
+    }), r.tabbableGroups.length <= 0 && !k("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 (r.containerGroups.find(function(n) {
+      return n.posTabIndexesFound;
+    }) && r.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.");
+  }, R = function(n) {
+    var o = n.activeElement;
+    if (o)
+      return o.shadowRoot && o.shadowRoot.activeElement !== null ? R(o.shadowRoot) : o;
+  }, C = function(n) {
+    if (n !== !1 && n !== R(document)) {
+      if (!n || !n.focus) {
+        C(w());
+        return;
+      }
+      n.focus({
+        preventScroll: !!l.preventScroll
+      }), r.mostRecentlyFocusedNode = n, He(n) && n.select();
+    }
+  }, Q = function(n) {
+    var o = k("setReturnFocus", {
+      params: [n]
+    });
+    return o || (o === !1 ? !1 : n);
+  }, ee = function(n) {
+    var o = n.target, c = n.event, d = n.isBackward, f = d === void 0 ? !1 : d;
+    o = o || z(c), S();
+    var h = null;
+    if (r.tabbableGroups.length > 0) {
+      var u = g(o, c), m = u >= 0 ? r.containerGroups[u] : void 0;
+      if (u < 0)
+        f ? h = r.tabbableGroups[r.tabbableGroups.length - 1].lastTabbableNode : h = r.tabbableGroups[0].firstTabbableNode;
+      else if (f) {
+        var y = r.tabbableGroups.findIndex(function(U) {
+          var V = U.firstTabbableNode;
+          return o === V;
+        });
+        if (y < 0 && (m.container === o || W(o, l.tabbableOptions) && !P(o, l.tabbableOptions) && !m.nextTabbableNode(o, !1)) && (y = u), y >= 0) {
+          var D = y === 0 ? r.tabbableGroups.length - 1 : y - 1, x = r.tabbableGroups[D];
+          h = A(o) >= 0 ? x.lastTabbableNode : x.lastDomTabbableNode;
+        } else _(c) || (h = m.nextTabbableNode(o, !1));
+      } else {
+        var F = r.tabbableGroups.findIndex(function(U) {
+          var V = U.lastTabbableNode;
+          return o === V;
+        });
+        if (F < 0 && (m.container === o || W(o, l.tabbableOptions) && !P(o, l.tabbableOptions) && !m.nextTabbableNode(o)) && (F = u), F >= 0) {
+          var B = F === r.tabbableGroups.length - 1 ? 0 : F + 1, se = r.tabbableGroups[B];
+          h = A(o) >= 0 ? se.firstTabbableNode : se.firstDomTabbableNode;
+        } else _(c) || (h = m.nextTabbableNode(o));
+      }
+    } else
+      h = k("fallbackFocus");
+    return h;
+  }, K = function(n) {
+    var o = z(n);
+    if (!(g(o, n) >= 0)) {
+      if (L(l.clickOutsideDeactivates, n)) {
+        b.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;
+      }
+      L(l.allowOutsideClick, n) || n.preventDefault();
+    }
+  }, te = function(n) {
+    var o = z(n), c = g(o, n) >= 0;
+    if (c || o instanceof Document)
+      c && (r.mostRecentlyFocusedNode = o);
+    else {
+      n.stopImmediatePropagation();
+      var d, f = !0;
+      if (r.mostRecentlyFocusedNode)
+        if (A(r.mostRecentlyFocusedNode) > 0) {
+          var h = g(r.mostRecentlyFocusedNode), u = r.containerGroups[h].tabbableNodes;
+          if (u.length > 0) {
+            var m = u.findIndex(function(y) {
+              return y === r.mostRecentlyFocusedNode;
+            });
+            m >= 0 && (l.isKeyForward(r.recentNavEvent) ? m + 1 < u.length && (d = u[m + 1], f = !1) : m - 1 >= 0 && (d = u[m - 1], f = !1));
+          }
+        } else
+          r.containerGroups.some(function(y) {
+            return y.tabbableNodes.some(function(D) {
+              return A(D) > 0;
+            });
+          }) || (f = !1);
+      else
+        f = !1;
+      f && (d = ee({
+        // 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: r.mostRecentlyFocusedNode,
+        isBackward: l.isKeyBackward(r.recentNavEvent)
+      })), C(d || r.mostRecentlyFocusedNode || w());
+    }
+    r.recentNavEvent = void 0;
+  }, ye = function(n) {
+    var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    r.recentNavEvent = n;
+    var c = ee({
+      event: n,
+      isBackward: o
+    });
+    c && (_(n) && n.preventDefault(), C(c));
+  }, ae = function(n) {
+    (l.isKeyForward(n) || l.isKeyBackward(n)) && ye(n, l.isKeyBackward(n));
+  }, re = function(n) {
+    Ze(n) && L(l.escapeDeactivates, n) !== !1 && (n.preventDefault(), b.deactivate());
+  }, ie = function(n) {
+    var o = z(n);
+    g(o, n) >= 0 || L(l.clickOutsideDeactivates, n) || L(l.allowOutsideClick, n) || (n.preventDefault(), n.stopImmediatePropagation());
+  }, ne = function() {
+    if (r.active)
+      return de.activateTrap(s, b), r.delayInitialFocusTimer = l.delayInitialFocus ? fe(function() {
+        C(w());
+      }) : C(w()), a.addEventListener("focusin", te, !0), a.addEventListener("mousedown", K, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("touchstart", K, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("click", ie, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", ae, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", re), b;
+  }, oe = function() {
+    if (r.active)
+      return a.removeEventListener("focusin", te, !0), a.removeEventListener("mousedown", K, !0), a.removeEventListener("touchstart", K, !0), a.removeEventListener("click", ie, !0), a.removeEventListener("keydown", ae, !0), a.removeEventListener("keydown", re), b;
+  }, we = function(n) {
+    var o = n.some(function(c) {
+      var d = Array.from(c.removedNodes);
+      return d.some(function(f) {
+        return f === r.mostRecentlyFocusedNode;
+      });
+    });
+    o && C(w());
+  }, Y = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(we) : void 0, I = function() {
+    Y && (Y.disconnect(), r.active && !r.paused && r.containers.map(function(n) {
+      Y.observe(n, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return b = {
+    get active() {
+      return r.active;
+    },
+    get paused() {
+      return r.paused;
+    },
+    activate: function(n) {
+      if (r.active)
+        return this;
+      var o = v(n, "onActivate"), c = v(n, "onPostActivate"), d = v(n, "checkCanFocusTrap");
+      d || S(), r.active = !0, r.paused = !1, r.nodeFocusedBeforeActivation = R(a), o?.();
+      var f = function() {
+        d && S(), ne(), I(), c?.();
+      };
+      return d ? (d(r.containers.concat()).then(f, f), this) : (f(), this);
+    },
+    deactivate: function(n) {
+      if (!r.active)
+        return this;
+      var o = ue({
+        onDeactivate: l.onDeactivate,
+        onPostDeactivate: l.onPostDeactivate,
+        checkCanReturnFocus: l.checkCanReturnFocus
+      }, n);
+      clearTimeout(r.delayInitialFocusTimer), r.delayInitialFocusTimer = void 0, oe(), r.active = !1, r.paused = !1, I(), de.deactivateTrap(s, b);
+      var c = v(o, "onDeactivate"), d = v(o, "onPostDeactivate"), f = v(o, "checkCanReturnFocus"), h = v(o, "returnFocus", "returnFocusOnDeactivate");
+      c?.();
+      var u = function() {
+        fe(function() {
+          h && C(Q(r.nodeFocusedBeforeActivation)), d?.();
+        });
+      };
+      return h && f ? (f(Q(r.nodeFocusedBeforeActivation)).then(u, u), this) : (u(), this);
+    },
+    pause: function(n) {
+      return r.active ? (r.manuallyPaused = !0, this._setPausedState(!0, n)) : this;
+    },
+    unpause: function(n) {
+      return r.active ? (r.manuallyPaused = !1, s[s.length - 1] !== this ? this : this._setPausedState(!1, n)) : this;
+    },
+    updateContainerElements: function(n) {
+      var o = [].concat(n).filter(Boolean);
+      return r.containers = o.map(function(c) {
+        return typeof c == "string" ? a.querySelector(c) : c;
+      }), r.active && S(), I(), this;
+    }
+  }, Object.defineProperties(b, {
+    _isManuallyPaused: {
+      value: function() {
+        return r.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(n, o) {
+        if (r.paused === n)
+          return this;
+        if (r.paused = n, n) {
+          var c = v(o, "onPause"), d = v(o, "onPostPause");
+          c?.(), oe(), I(), d?.();
+        } else {
+          var f = v(o, "onUnpause"), h = v(o, "onPostUnpause");
+          f?.(), S(), ne(), I(), h?.();
+        }
+        return this;
+      }
+    }
+  }), b.updateContainerElements(e), b;
+}, at = Object.defineProperty, N = (i, e, t, a) => {
+  for (var s = void 0, l = i.length - 1, r; l >= 0; l--)
+    (r = i[l]) && (s = r(e, t, s) || s);
+  return s && at(e, t, s), s;
+};
+const J = class J extends ke {
+  constructor() {
+    super(), this._focusTrap = null, this._handleKeydown = (e) => {
+      if (e.key === "Escape" && !this.noCloseOnEscape) {
+        e.preventDefault();
+        const t = new CustomEvent("dialog-cancel", { bubbles: !0, composed: !0 });
+        this.dispatchEvent(t), this.onDialogCancel?.(t), this.open = !1;
+        return;
+      }
+      if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key)) {
+        const t = document.activeElement;
+        if (t && Ne(t, this.shadowRoot, this)) {
+          if (t.tagName === "INPUT" && t.type === "radio")
+            return;
+          e.stopPropagation();
+        }
+      }
+    }, this._handleBackdropClick = (e) => {
+      if (!(this.noCloseOnBackdrop || !this.open) && Ee(e, this.shadowRoot, ".dialog-container")) {
+        const t = new CustomEvent("dialog-cancel", { bubbles: !0, composed: !0 });
+        this.dispatchEvent(t), this.onDialogCancel?.(t), this.open = !1;
+      }
+    }, this._handleCloseButtonClick = (e) => {
+      e.stopPropagation();
+      const t = new CustomEvent("dialog-close", { bubbles: !0, composed: !0 });
+      this.dispatchEvent(t), this.onDialogClose?.(t), this.open = !1;
+    }, this.open = !1, this.heading = "", this.description = "", this.noCloseOnEscape = !1, this.noCloseOnBackdrop = !1, this.showCloseButton = !1, this.drawerPosition = void 0;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.open && (document.removeEventListener("keydown", this._handleKeydown), this._restoreBackgroundScroll()), this._focusTrap && (this._focusTrap.deactivate(), this._focusTrap = null);
+  }
+  willUpdate(e) {
+    if (e.has("open")) {
+      const t = e.get("open");
+      if (this.open && !t) {
+        document.addEventListener("keydown", this._handleKeydown), this._preventBackgroundScroll();
+        const a = new CustomEvent("dialog-open", { bubbles: !0, composed: !0 });
+        this.dispatchEvent(a), this.onDialogOpen?.(a);
+      } else if (!this.open && t) {
+        document.removeEventListener("keydown", this._handleKeydown);
+        const a = new CustomEvent("dialog-close", { bubbles: !0, composed: !0 });
+        this.dispatchEvent(a), this.onDialogClose?.(a), this._restoreBackgroundScroll(), this._focusTrap && (this._focusTrap.deactivate(), this._focusTrap = null);
+      }
+    }
+  }
+  _preventBackgroundScroll() {
+    const e = parseInt(document.body.getAttribute("data-dialog-count") || "0", 10);
+    e === 0 && (document.body.setAttribute(
+      "data-dialog-original-overflow",
+      document.body.style.overflow || ""
+    ), document.body.style.overflow = "hidden", document.body.setAttribute("data-dialog-scroll-locked", "")), document.body.setAttribute("data-dialog-count", (e + 1).toString());
+  }
+  _restoreBackgroundScroll() {
+    const e = parseInt(document.body.getAttribute("data-dialog-count") || "0", 10), t = Math.max(0, e - 1);
+    if (document.body.setAttribute("data-dialog-count", t.toString()), t === 0) {
+      const a = document.body.getAttribute("data-dialog-original-overflow");
+      document.body.style.overflow = a || "", document.body.removeAttribute("data-dialog-original-overflow"), document.body.removeAttribute("data-dialog-scroll-locked"), document.body.removeAttribute("data-dialog-count");
+    }
+  }
+  updated(e) {
+    if (e.has("open") && this.open) {
+      const t = this.shadowRoot?.querySelector(".dialog-container"), a = () => {
+        if (!t) return;
+        const s = this.getRootNode().host || this;
+        this._focusTrap = tt([t, s], {
+          escapeDeactivates: !1,
+          // We handle Escape ourselves
+          clickOutsideDeactivates: !1,
+          // We handle backdrop clicks ourselves
+          returnFocusOnDeactivate: !0,
+          // Auto-restore focus when deactivated
+          allowOutsideClick: !0,
+          // Allow clicks outside (we handle backdrop)
+          fallbackFocus: t,
+          // Focus container if no focusable elements
+          // Enable Shadow DOM support
+          tabbableOptions: {
+            getShadowRoot: !0
+          }
+        }), this._focusTrap.activate();
+      };
+      if (t) {
+        const s = getComputedStyle(t), l = parseFloat(s.transitionDuration), r = s.transitionProperty;
+        l > 0 && r !== "none" ? t.addEventListener("transitionend", a, { once: !0 }) : setTimeout(a, 0);
+      } else
+        setTimeout(a, 0);
+    }
+  }
+  render() {
+    return j`
+      <div
+        class="dialog-backdrop"
+        part="ag-dialog-backdrop"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby=${this.heading ? "dialog-heading" : X}
+        aria-label=${this.heading ? X : "Dialog"}
+        aria-describedby=${this.description ? "dialog-description" : X}
+        @click=${this._handleBackdropClick}
+      >
+        <div class="dialog-container" part="ag-dialog-container">
+          <div class="dialog-header" part="ag-dialog-header">
+            <slot name="header">
+              ${this.heading ? j`<h2 id="dialog-heading" part="ag-dialog-heading">${this.heading}</h2>` : ""}
+            </slot>
+            ${this.showCloseButton ? j`
+              <ag-close-button
+                position="top-end"
+                label="Close dialog"
+                @close-button-click=${this._handleCloseButtonClick}
+              ></ag-close-button>
+            ` : ""}
+          </div>
+          <div class="dialog-content" part="ag-dialog-content">
+            ${this.description ? j`<p id="dialog-description">${this.description}</p>` : ""}
+            <slot></slot>
+          </div>
+          <div class="dialog-footer" part="ag-dialog-footer">
+            <slot name="footer"></slot>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+};
+J.styles = Te`
+    :host {
+      display: block;
+      visibility: hidden;
+      position: fixed;
+      inset: 0;
+      width: 100%;
+      height: 100%;
+      z-index: var(--ag-z-index-modal);
+    }
+
+    :host([open]) {
+      visibility: visible;
+    }
+
+    .dialog-backdrop {
+      position: absolute;
+      top: 0;
+      inset-inline-start: 0;
+      width: 100%;
+      height: 100%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background-color: rgb(50 50 50 / 60%);
+      opacity: 0;
+      transition: opacity var(--ag-motion-fast) ease;
+    }
+
+    :host([open]) .dialog-backdrop {
+      opacity: 1;
+    }
+
+    .dialog-container {
+      overflow-y: auto;
+      max-inline-size: 90vw;
+      max-block-size: 90vh;
+      position: relative;
+      background: var(--ag-background-primary);
+      border: 1px solid var(--ag-border);
+      border-radius: var(--ag-radius-lg);
+      padding: var(--ag-space-6);
+      margin: var(--ag-space-4);
+      opacity: 0;
+      transform: translateY(10%);
+      transition: opacity var(--ag-motion-fast) ease, transform var(--ag-motion-slow) ease var(--ag-motion-fast);
+    }
+
+    :host([open]) .dialog-container {
+      opacity: 1;
+      transform: translateY(0);
+    }
+
+    /* Drawer positioning styles */
+    :host([drawer-position]) {
+      /* Host sizing for edge positions */
+    }
+
+    :host([drawer-position="start"]),
+    :host([drawer-position="end"]) {
+      height: 100%;
+    }
+
+    :host([drawer-position="top"]),
+    :host([drawer-position="bottom"]) {
+      width: 100%;
+    }
+
+    /* Base drawer container setup */
+    :host([drawer-position]) .dialog-container {
+      box-sizing: border-box;
+      position: fixed;
+      margin: initial;
+      border-radius: 0;
+    }
+
+    /* Vertical edge positions (start/end) sizing */
+    :host([drawer-position="start"]) .dialog-container,
+    :host([drawer-position="end"]) .dialog-container {
+      height: 100%;
+      width: var(--ag-drawer-width);
+      max-block-size: initial;
+    }
+
+    /* Horizontal edge positions (top/bottom) sizing */
+    :host([drawer-position="top"]) .dialog-container,
+    :host([drawer-position="bottom"]) .dialog-container {
+      height: var(--ag-sheet-height);
+      width: 100%;
+      max-inline-size: initial;
+    }
+
+    /* Top position - closed state */
+    :host([drawer-position="top"]) .dialog-container {
+      top: 0;
+      transform: translateY(-100%);
+    }
+
+    /* Bottom position - closed state */
+    :host([drawer-position="bottom"]) .dialog-container {
+      bottom: 0;
+      transform: translateY(100%);
+    }
+
+    /* Start position - closed state */
+    :host([drawer-position="start"]) .dialog-container {
+      inset-inline-start: 0;
+      transform: translateX(-100%);
+    }
+
+    /* End position - closed state */
+    :host([drawer-position="end"]) .dialog-container {
+      inset-inline-end: 0;
+      transform: translateX(100%);
+    }
+
+    /* RTL Support - flip transform directions for start/end drawers */
+    :host-context([dir="rtl"]):host([drawer-position="start"]) .dialog-container {
+      transform: translateX(100%);
+    }
+
+    :host-context([dir="rtl"]):host([drawer-position="end"]) .dialog-container {
+      transform: translateX(-100%);
+    }
+
+    /* Open state - remove transforms to slide into view */
+    :host([drawer-position="top"][open]) .dialog-container,
+    :host([drawer-position="bottom"][open]) .dialog-container,
+    :host([drawer-position="start"][open]) .dialog-container,
+    :host([drawer-position="end"][open]) .dialog-container {
+      transform: none;
+    }
+
+    .dialog-header {
+      margin-block-end: var(--ag-space-4);
+    }
+
+    .dialog-header h2 {
+      margin: 0;
+      font-size: var(--ag-font-size-lg);
+      font-weight: var(--ag-font-weight-semibold);
+      color: var(--ag-text-primary);
+    }
+
+    .dialog-content {
+      margin-block-end: var(--ag-space-4);
+    }
+
+    .dialog-content:last-child {
+      margin-block-end: 0;
+    }
+
+    .dialog-content p {
+      margin: 0 0 var(--ag-space-4) 0;
+      color: var(--ag-text-secondary);
+    }
+
+    .dialog-footer {
+      margin-block-start: var(--ag-space-4);
+    }
+
+    .dialog-footer:empty {
+      margin-block-start: 0;
+    }
+
+    @media (prefers-reduced-motion: reduce) {
+      .dialog-backdrop,
+      .dialog-container {
+        transition: none;
+      }
+    }
+  `;
+let T = J;
+N([
+  E({ type: Boolean, reflect: !0 })
+], T.prototype, "open");
+N([
+  E({ type: String })
+], T.prototype, "heading");
+N([
+  E({ type: String })
+], T.prototype, "description");
+N([
+  E({ type: Boolean })
+], T.prototype, "noCloseOnEscape");
+N([
+  E({ type: Boolean })
+], T.prototype, "noCloseOnBackdrop");
+N([
+  E({ type: Boolean })
+], T.prototype, "showCloseButton");
+N([
+  E({ type: String, reflect: !0, attribute: "drawer-position" })
+], T.prototype, "drawerPosition");
+N([
+  E({ attribute: !1 })
+], T.prototype, "onDialogOpen");
+N([
+  E({ attribute: !1 })
+], T.prototype, "onDialogClose");
+N([
+  E({ attribute: !1 })
+], T.prototype, "onDialogCancel");
+export {
+  T as AgnosticDialog
+};