@dso-toolkit/core 88.1.0 → 89.0.0

package/dist/bundle/dso-advanced-select.js

@@ -1,15 +1,15 @@
-import { p as proxyCustomElement, H, d as createEvent, h, F as Fragment, t as transformTag } from './p-DBWrx_3r.js';
+import { p as proxyCustomElement, H, d as createEvent, h, F as Fragment, t as transformTag } from './p-DmmKAUIT.js';
 import { c as clsx } from './p-ChV9xqsO.js';
-import { t as tabbable, f as focusable, i as isTabbable, g as getTabIndex, a as isFocusable } from './p-DDSMs62-.js';
+import { i as isFocusable, t as tabbable, f as focusable, a as isTabbable, g as getTabIndex } from './p-PsHl6ZhV.js';
 import { i as isModifiedEvent } from './p-Hgv-pDpy.js';
-import { d as defineCustomElement$6 } from './p-BM-R_z20.js';
-import { d as defineCustomElement$5 } from './p-Btk7RWKm.js';
-import { d as defineCustomElement$4 } from './p-DpRZJt_D.js';
-import { d as defineCustomElement$3 } from './p-BJqFBnN6.js';
-import { d as defineCustomElement$2 } from './p-CBhOl8xD.js';
+import { d as defineCustomElement$6 } from './p-CC5mzX8a.js';
+import { d as defineCustomElement$5 } from './p-DOIYXIWP.js';
+import { d as defineCustomElement$4 } from './p-DK5tN6xk.js';
+import { d as defineCustomElement$3 } from './p-D4NMNwP8.js';
+import { d as defineCustomElement$2 } from './p-BO0PFU2G.js';
 
 /*!
-* focus-trap 7.6.6
+* focus-trap 8.0.0
 * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
 */
 
@@ -21,6 +21,79 @@ function _arrayLikeToArray(r, a) {
 function _arrayWithoutHoles(r) {
   if (Array.isArray(r)) return _arrayLikeToArray(r);
 }
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
@@ -56,6 +129,109 @@ function _objectSpread2(e) {
   }
   return e;
 }
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
 function _toConsumableArray(r) {
   return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
 }
@@ -82,12 +258,18 @@ function _unsupportedIterableToArray(r, a) {
 }
 
 var activeFocusTraps = {
+  // Returns the trap from the top of the stack.
+  getActiveTrap: function getActiveTrap(trapStack) {
+    if ((trapStack === null || trapStack === void 0 ? void 0 : trapStack.length) > 0) {
+      return trapStack[trapStack.length - 1];
+    }
+    return null;
+  },
+  // Pauses the currently active trap, then adds a new trap to the stack.
   activateTrap: function activateTrap(trapStack, trap) {
-    if (trapStack.length > 0) {
-      var activeTrap = trapStack[trapStack.length - 1];
-      if (activeTrap !== trap) {
-        activeTrap._setPausedState(true);
-      }
+    var activeTrap = activeFocusTraps.getActiveTrap(trapStack);
+    if (trap !== activeTrap) {
+      activeFocusTraps.pauseTrap(trapStack);
     }
     var trapIndex = trapStack.indexOf(trap);
     if (trapIndex === -1) {
@@ -98,13 +280,24 @@ var activeFocusTraps = {
       trapStack.push(trap);
     }
   },
+  // Removes the trap from the top of the stack, then unpauses the next trap down.
   deactivateTrap: function deactivateTrap(trapStack, trap) {
     var trapIndex = trapStack.indexOf(trap);
     if (trapIndex !== -1) {
       trapStack.splice(trapIndex, 1);
     }
-    if (trapStack.length > 0 && !trapStack[trapStack.length - 1]._isManuallyPaused()) {
-      trapStack[trapStack.length - 1]._setPausedState(false);
+    activeFocusTraps.unpauseTrap(trapStack);
+  },
+  // Pauses the trap at the top of the stack.
+  pauseTrap: function pauseTrap(trapStack) {
+    var activeTrap = activeFocusTraps.getActiveTrap(trapStack);
+    activeTrap === null || activeTrap === void 0 || activeTrap._setPausedState(true);
+  },
+  // Unpauses the trap at the top of the stack.
+  unpauseTrap: function unpauseTrap(trapStack) {
+    var activeTrap = activeFocusTraps.getActiveTrap(trapStack);
+    if (activeTrap && !activeTrap._isManuallyPaused()) {
+      activeTrap._setPausedState(false);
     }
   }
 };
@@ -167,29 +360,31 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
     returnFocusOnDeactivate: true,
     escapeDeactivates: true,
     delayInitialFocus: true,
+    isolateSubtrees: false,
     isKeyForward: isKeyForward,
     isKeyBackward: isKeyBackward
   }, userOptions);
   var state = {
     // containers given to createFocusTrap()
-    // @type {Array<HTMLElement>}
+    /** @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
-    // }>}
+    /** @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
 
@@ -198,6 +393,12 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
     // 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: new Set(),
+    // references to nodes that were inert or aria-hidden before the trap was activated.
+    /** @type {Set<HTMLElement>} */
+    alreadySilent: new Set(),
     nodeFocusedBeforeActivation: null,
     mostRecentlyFocusedNode: null,
     active: false,
@@ -585,7 +786,7 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
   var checkPointerDown = function checkPointerDown(e) {
     var target = getActualTarget(e);
     if (findContainerIndex(target, e) >= 0) {
-      // allow the click since it ocurred inside the trap
+      // allow the click since it occurred inside the trap
       return;
     }
     if (valueOrHandler(config.clickOutsideDeactivates, e)) {
@@ -768,9 +969,15 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
   // EVENT LISTENERS
   //
 
+  /**
+   * Adds listeners to the document necessary for trapping focus and attempts to set focus
+   *  to the configured initial focus node. Does nothing if the trap isn't active.
+   * @returns {Promise<void>} Resolved (always) once the initial focus node has been focused.
+   *  Also resolved if the trap isn't active.
+   */
   var addListeners = function addListeners() {
     if (!state.active) {
-      return;
+      return Promise.resolve();
     }
 
     // There can be only one listening focus trap at a time
@@ -778,9 +985,21 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
 
     // Delay ensures that the focused element doesn't capture the event
     // that caused the focus trap activation.
-    state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function () {
+    /** @type {Promise<void>} */
+    var promise;
+    if (config.delayInitialFocus) {
+      // NOTE: Promise constructor callback is called synchronously, which is what we want
+      //  since we need to capture the timer ID immediately
+      promise = new Promise(function (resolve) {
+        state.delayInitialFocusTimer = delay(function () {
+          _tryFocus(getInitialFocusNode());
+          resolve();
+        });
+      });
+    } else {
+      promise = Promise.resolve();
       _tryFocus(getInitialFocusNode());
-    }) : _tryFocus(getInitialFocusNode());
+    }
     doc.addEventListener('focusin', checkFocusIn, true);
     doc.addEventListener('mousedown', checkPointerDown, {
       capture: true,
@@ -799,7 +1018,75 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
       passive: false
     });
     doc.addEventListener('keydown', checkEscapeKey);
-    return trap;
+    return promise;
+  };
+
+  /**
+   * Traverses up the DOM from each of `containers`, collecting references to
+   * the elements that are siblings to `container` or an ancestor of `container`.
+   * @param {Array<HTMLElement>} containers
+   */
+  var collectAdjacentElements = function collectAdjacentElements(containers) {
+    // Re-activate all adjacent elements & clear previous collection.
+    if (state.active && !state.paused) {
+      trap._setSubtreeIsolation(false);
+    }
+    state.adjacentElements.clear();
+    state.alreadySilent.clear();
+
+    // Collect all ancestors of all containers to avoid redundant processing.
+    var containerAncestors = new Set();
+    var adjacentElements = new Set();
+
+    // Compile all elements adjacent to the focus trap containers & lineage.
+    var _iterator = _createForOfIteratorHelper(containers),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var container = _step.value;
+        containerAncestors.add(container);
+        var insideShadowRoot = typeof ShadowRoot !== 'undefined' && container.getRootNode() instanceof ShadowRoot;
+        var current = container;
+        while (current) {
+          containerAncestors.add(current);
+          var parent = current.parentElement;
+          var siblings = [];
+          if (parent) {
+            siblings = parent.children;
+          } else if (!parent && insideShadowRoot) {
+            siblings = current.getRootNode().children;
+            parent = current.getRootNode().host;
+            insideShadowRoot = typeof ShadowRoot !== 'undefined' && parent.getRootNode() instanceof ShadowRoot;
+          }
+
+          // Add all the children, we'll remove container lineage later.
+          var _iterator2 = _createForOfIteratorHelper(siblings),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var child = _step2.value;
+              adjacentElements.add(child);
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+          current = parent;
+        }
+      }
+
+      // Multi-container traps may overlap.
+      // Remove elements within container lineages.
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    containerAncestors.forEach(function (el) {
+      adjacentElements["delete"](el);
+    });
+    state.adjacentElements = adjacentElements;
   };
   var removeListeners = function removeListeners() {
     if (!state.active) {
@@ -869,26 +1156,73 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
       var onActivate = getOption(activateOptions, 'onActivate');
       var onPostActivate = getOption(activateOptions, 'onPostActivate');
       var checkCanFocusTrap = getOption(activateOptions, 'checkCanFocusTrap');
-      if (!checkCanFocusTrap) {
-        updateTabbableNodes();
+
+      // If a currently-active trap is isolating its subtree, we need to remove
+      // that isolation to allow the new trap to find tabbable nodes.
+      var preexistingTrap = activeFocusTraps.getActiveTrap(trapStack);
+      var revertState = false;
+      if (preexistingTrap && !preexistingTrap.paused) {
+        var _preexistingTrap$_set;
+        // [#1729] method MAY not exist if using `trapStack` option to share stack with older
+        //  versions of Focus-trap in the same DOM so use optional chaining here just in case
+        //  since this is a trap we may not have created from this instance of the library
+        (_preexistingTrap$_set = preexistingTrap._setSubtreeIsolation) === null || _preexistingTrap$_set === void 0 || _preexistingTrap$_set.call(preexistingTrap, false);
+        revertState = true;
       }
-      state.active = true;
-      state.paused = false;
-      state.nodeFocusedBeforeActivation = _getActiveElement(doc);
-      onActivate === null || onActivate === void 0 || onActivate();
-      var finishActivation = function finishActivation() {
-        if (checkCanFocusTrap) {
+      try {
+        if (!checkCanFocusTrap) {
           updateTabbableNodes();
         }
-        addListeners();
-        updateObservedNodes();
-        onPostActivate === null || onPostActivate === void 0 || onPostActivate();
-      };
-      if (checkCanFocusTrap) {
-        checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
-        return this;
+        state.active = true;
+        state.paused = false;
+        state.nodeFocusedBeforeActivation = _getActiveElement(doc);
+        onActivate === null || onActivate === void 0 || onActivate();
+        var finishActivation = /*#__PURE__*/function () {
+          var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+            return _regenerator().w(function (_context) {
+              while (1) switch (_context.n) {
+                case 0:
+                  if (checkCanFocusTrap) {
+                    updateTabbableNodes();
+                  }
+
+                  // NOTE: wait for initial focus node to get focused before we potentially isolate
+                  //  the subtrees with aria-hidden while focus is still in some other subtree and
+                  //  not yet in the trap, resulting in some browsers (e.g. Chrome) logging to the
+                  //  console that they, "Blocked aria-hidden on an element because its descendant
+                  //  retained focus..."
+                  _context.n = 1;
+                  return addListeners();
+                case 1:
+                  trap._setSubtreeIsolation(true);
+                  updateObservedNodes();
+                  onPostActivate === null || onPostActivate === void 0 || onPostActivate();
+                case 2:
+                  return _context.a(2);
+              }
+            }, _callee);
+          }));
+          return function finishActivation() {
+            return _ref6.apply(this, arguments);
+          };
+        }();
+        if (checkCanFocusTrap) {
+          checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
+          return this;
+        }
+        finishActivation();
+      } catch (error) {
+        // If our activation throws an exception and the stack hasn't changed,
+        // we need to re-enable the prior trap's subtree isolation.
+        if (preexistingTrap === activeFocusTraps.getActiveTrap(trapStack) && revertState) {
+          var _preexistingTrap$_set2;
+          // [#1729] method MAY not exist if using `trapStack` option to share stack with older
+          //  versions of Focus-trap in the same DOM so use optional chaining here just in case
+          //  since this is a trap we may not have created from this instance of the library
+          (_preexistingTrap$_set2 = preexistingTrap._setSubtreeIsolation) === null || _preexistingTrap$_set2 === void 0 || _preexistingTrap$_set2.call(preexistingTrap, true);
+        }
+        throw error;
       }
-      finishActivation();
       return this;
     },
     deactivate: function deactivate(deactivateOptions) {
@@ -902,6 +1236,15 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
       }, deactivateOptions);
       clearTimeout(state.delayInitialFocusTimer); // noop if undefined
       state.delayInitialFocusTimer = undefined;
+
+      // Prior to removing this trap from the trapStack, we need to remove any applications of `inert`.
+      // This allows the next trap down to update its tabbable nodes properly.
+      //
+      // If this trap is not top of the stack, don't change any current isolation.
+      if (!state.paused) {
+        trap._setSubtreeIsolation(false);
+      }
+      state.alreadySilent.clear();
       removeListeners();
       state.active = false;
       state.paused = false;
@@ -949,8 +1292,14 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
       state.containers = elementsAsArray.map(function (element) {
         return typeof element === 'string' ? doc.querySelector(element) : element;
       });
+      if (config.isolateSubtrees) {
+        collectAdjacentElements(state.containers);
+      }
       if (state.active) {
         updateTabbableNodes();
+        if (!state.paused) {
+          trap._setSubtreeIsolation(true);
+        }
       }
       updateObservedNodes();
       return this;
@@ -973,19 +1322,84 @@ var createFocusTrap = function createFocusTrap(elements, userOptions) {
           var onPostPause = getOption(options, 'onPostPause');
           onPause === null || onPause === void 0 || onPause();
           removeListeners();
+          trap._setSubtreeIsolation(false);
           updateObservedNodes();
           onPostPause === null || onPostPause === void 0 || onPostPause();
         } else {
           var onUnpause = getOption(options, 'onUnpause');
           var onPostUnpause = getOption(options, 'onPostUnpause');
           onUnpause === null || onUnpause === void 0 || onUnpause();
-          updateTabbableNodes();
-          addListeners();
-          updateObservedNodes();
-          onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();
+          var finishUnpause = /*#__PURE__*/function () {
+            var _ref7 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+              return _regenerator().w(function (_context2) {
+                while (1) switch (_context2.n) {
+                  case 0:
+                    updateTabbableNodes();
+
+                    // NOTE: wait for initial focus node to get focused before we potentially isolate
+                    //  the subtrees with aria-hidden while focus is still in some other subtree and
+                    //  not yet in the trap, resulting in some browsers (e.g. Chrome) logging to the
+                    //  console that they, "Blocked aria-hidden on an element because its descendant
+                    //  retained focus..."
+                    _context2.n = 1;
+                    return addListeners();
+                  case 1:
+                    trap._setSubtreeIsolation(true);
+                    updateObservedNodes();
+                    onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();
+                  case 2:
+                    return _context2.a(2);
+                }
+              }, _callee2);
+            }));
+            return function finishUnpause() {
+              return _ref7.apply(this, arguments);
+            };
+          }();
+          finishUnpause();
         }
         return this;
       }
+    },
+    _setSubtreeIsolation: {
+      value: function value(isEnabled) {
+        if (config.isolateSubtrees) {
+          state.adjacentElements.forEach(function (el) {
+            var _el$getAttribute;
+            if (isEnabled) {
+              switch (config.isolateSubtrees) {
+                case 'aria-hidden':
+                  // check both attribute and property to ensure initial state is captured
+                  // correctly across different browsers and test environments (like JSDOM)
+                  if (el.ariaHidden === 'true' || ((_el$getAttribute = el.getAttribute('aria-hidden')) === null || _el$getAttribute === void 0 ? void 0 : _el$getAttribute.toLowerCase()) === 'true') {
+                    state.alreadySilent.add(el);
+                  }
+                  el.setAttribute('aria-hidden', 'true');
+                  break;
+                default:
+                  // check both attribute and property to ensure initial state is captured
+                  // correctly across different browsers and test environments (like JSDOM)
+                  if (el.inert || el.hasAttribute('inert')) {
+                    state.alreadySilent.add(el);
+                  }
+                  el.setAttribute('inert', true);
+                  break;
+              }
+            } else {
+              if (state.alreadySilent.has(el)) ; else {
+                switch (config.isolateSubtrees) {
+                  case 'aria-hidden':
+                    el.removeAttribute('aria-hidden');
+                    break;
+                  default:
+                    el.removeAttribute('inert');
+                    break;
+                }
+              }
+            }
+          });
+        }
+      }
     }
   });
 
@@ -1057,14 +1471,12 @@ const AdvancedSelect = /*@__PURE__*/ proxyCustomElement(class AdvancedSelect ext
         }).activate();
     }
     removeTrap() {
-        var _a;
-        (_a = this.trap) === null || _a === void 0 ? void 0 : _a.deactivate();
+        this.trap?.deactivate();
         delete this.trap;
     }
     handleTab(direction) {
-        var _a;
         const elements = this.host.isConnected ? tabbable(this.host, { getShadowRoot: true }) : [];
-        const currentIndex = elements.findIndex((e) => { var _a; return e === ((_a = this.host.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement); });
+        const currentIndex = elements.findIndex((e) => e === this.host.shadowRoot?.activeElement);
         let nextIndex = currentIndex + direction;
         if (nextIndex >= elements.length) {
             nextIndex = 0;
@@ -1072,21 +1484,17 @@ const AdvancedSelect = /*@__PURE__*/ proxyCustomElement(class AdvancedSelect ext
         else if (nextIndex < 0) {
             nextIndex = elements.length - 1;
         }
-        (_a = elements[nextIndex]) === null || _a === void 0 ? void 0 : _a.focus();
+        elements[nextIndex]?.focus();
     }
     render() {
-        var _a, _b;
-        return (h(Fragment, { key: '6bc4383d960ab9b0a14cb398464de6ebb0f9c187' }, h("button", { key: 'f10aa0612d85d21fe6b05e5bc8d971b5973347f9', "aria-expanded": this.open.toString(), class: clsx(["active-option", { open: this.open }]), type: "button", onClick: this.toggleOpen, ref: (element) => (this.toggleButtonElementRef = element) }, h(ActiveGroupLabel, { key: '61f78f3eb5791a29de2780af1c4c38432447f260', active: this.active, options: this.options }), h("span", { key: 'd519af3711abd178a33cb41d526b9f3685d9a73b', class: "active-option-label" }, (_b = (_a = this.active) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : "Selecteer een optie"), h("span", { key: '6ec080dbc881bba5282195b99cda44494dd0496c', class: "active-option-aside" }, this.options.some((optionOrGroup) => "summaryCounter" in optionOrGroup && (optionOrGroup === null || optionOrGroup === void 0 ? void 0 : optionOrGroup.summaryCounter)) && (h("span", { key: '88b4efa65736349f6ed9178bc41448fd0e27937b', class: "badges" }, this.options
-            .filter((option) => "options" in option && "summaryCounter" in option && !!(option === null || option === void 0 ? void 0 : option.summaryCounter))
-            .map((group) => {
-            var _a;
-            return (h("dso-badge", { status: (_a = group.variant) !== null && _a !== void 0 ? _a : "outline" }, group.options.length));
-        }))), h("dso-icon", { key: '9072cc0bd056301790e3e5ceffdedb48e1e1683c', icon: "caret-down" }))), this.open && (h("div", { key: 'db3269ccedbd03c6fb15fbdc8ab919755394c5c1', class: "groups-container" }, h("ul", { key: 'f6db478570a5d2f11d9df466eef1a68389694cdd', class: "groups" }, this.options.map((optionOrGroup) => ("options" in optionOrGroup && (h("li", { class: clsx(["group", { [`group-${optionOrGroup.variant}`]: !!optionOrGroup.variant }]) }, h("p", { class: "group-label" }, optionOrGroup.label), h("ul", { class: "options" }, optionOrGroup.options.map((option) => (h("li", null, h(OptionButton, { option: option, active: this.active, activeHint: this.activeHint, callback: this.handleOptionClick }))))), optionOrGroup.redirect && (h(RedirectAnchor, { redirect: optionOrGroup.redirect, callback: this.handleRedirectClick }))))) ||
+        return (h(Fragment, { key: '6bc4383d960ab9b0a14cb398464de6ebb0f9c187' }, h("button", { key: 'f10aa0612d85d21fe6b05e5bc8d971b5973347f9', "aria-expanded": this.open.toString(), class: clsx(["active-option", { open: this.open }]), type: "button", onClick: this.toggleOpen, ref: (element) => (this.toggleButtonElementRef = element) }, h(ActiveGroupLabel, { key: '61f78f3eb5791a29de2780af1c4c38432447f260', active: this.active, options: this.options }), h("span", { key: 'd519af3711abd178a33cb41d526b9f3685d9a73b', class: "active-option-label" }, this.active?.label ?? "Selecteer een optie"), h("span", { key: '6ec080dbc881bba5282195b99cda44494dd0496c', class: "active-option-aside" }, this.options.some((optionOrGroup) => "summaryCounter" in optionOrGroup && optionOrGroup?.summaryCounter) && (h("span", { key: '88b4efa65736349f6ed9178bc41448fd0e27937b', class: "badges" }, this.options
+            .filter((option) => "options" in option && "summaryCounter" in option && !!option?.summaryCounter)
+            .map((group) => (h("dso-badge", { status: group.variant ?? "outline" }, group.options.length))))), h("dso-icon", { key: '9072cc0bd056301790e3e5ceffdedb48e1e1683c', icon: "caret-down" }))), this.open && (h("div", { key: 'db3269ccedbd03c6fb15fbdc8ab919755394c5c1', class: "groups-container" }, h("ul", { key: 'f6db478570a5d2f11d9df466eef1a68389694cdd', class: "groups" }, this.options.map((optionOrGroup) => ("options" in optionOrGroup && (h("li", { class: clsx(["group", { [`group-${optionOrGroup.variant}`]: !!optionOrGroup.variant }]) }, h("p", { class: "group-label" }, optionOrGroup.label), h("ul", { class: "options" }, optionOrGroup.options.map((option) => (h("li", null, h(OptionButton, { option: option, active: this.active, activeHint: this.activeHint, callback: this.handleOptionClick }))))), optionOrGroup.redirect && (h(RedirectAnchor, { redirect: optionOrGroup.redirect, callback: this.handleRedirectClick }))))) ||
             ("placeholder" in optionOrGroup && (h("li", { class: "group" }, h("p", { class: "group-label" }, optionOrGroup.label), h("p", { class: "placeholder" }, optionOrGroup.placeholder), optionOrGroup.redirect && (h(RedirectAnchor, { redirect: optionOrGroup.redirect, callback: this.handleRedirectClick }))))) || (h("li", null, h(OptionButton, { option: optionOrGroup, active: this.active, activeHint: this.activeHint, callback: this.handleOptionClick })))))))));
     }
     get host() { return this; }
     static get style() { return advancedSelectCss(); }
-}, [257, "dso-advanced-select", {
+}, [1, "dso-advanced-select", {
         "options": [16],
         "active": [16],
         "activeHint": [1, "active-hint"],
@@ -1143,6 +1551,3 @@ const DsoAdvancedSelect = AdvancedSelect;
 const defineCustomElement = defineCustomElement$1;
 
 export { DsoAdvancedSelect, defineCustomElement };
-//# sourceMappingURL=dso-advanced-select.js.map
-
-//# sourceMappingURL=dso-advanced-select.js.map