@patternfly/react-core 4.219.1 → 4.219.2

package/dist/umd/react-core.js

@@ -123,12 +123,24 @@
     };
 
     /*!
-    * tabbable 5.1.4
+    * tabbable 5.3.2
     * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
     */
-    var candidateSelectors = ['input', 'select', 'textarea', 'a[href]', 'button', '[tabindex]', 'audio[controls]', 'video[controls]', '[contenteditable]:not([contenteditable="false"])', 'details>summary:first-of-type', 'details'];
+    var candidateSelectors = ['input', 'select', 'textarea', 'a[href]', 'button', '[tabindex]:not(slot)', 'audio[controls]', 'video[controls]', '[contenteditable]:not([contenteditable="false"])', 'details>summary:first-of-type', 'details'];
     var candidateSelector = /* #__PURE__ */candidateSelectors.join(',');
-    var matches = typeof Element === 'undefined' ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+    var NoElement = typeof Element === 'undefined';
+    var matches = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+    var getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {
+      return element.getRootNode();
+    } : function (element) {
+      return element.ownerDocument;
+    };
+    /**
+     * @param {Element} el container to check in
+     * @param {boolean} includeContainer add container to check
+     * @param {(node: Element) => boolean} filter filter candidates
+     * @returns {Element[]}
+     */
 
     var getCandidates = function getCandidates(el, includeContainer, filter) {
       var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
@@ -140,31 +152,112 @@
       candidates = candidates.filter(filter);
       return candidates;
     };
+    /**
+     * @callback GetShadowRoot
+     * @param {Element} element to check for shadow root
+     * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
+     */
+
+    /**
+     * @typedef {Object} CandidatesScope
+     * @property {Element} scope contains inner candidates
+     * @property {Element[]} candidates
+     */
+
+    /**
+     * @typedef {Object} IterativeOptions
+     * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
+     *  if a function, implies shadow support is enabled and either returns the shadow root of an element
+     *  or a boolean stating if it has an undisclosed shadow root
+     * @property {(node: Element) => boolean} filter filter candidates
+     * @property {boolean} flatten if true then result will flatten any CandidatesScope into the returned list
+     */
+
+    /**
+     * @param {Element[]} elements list of element containers to match candidates from
+     * @param {boolean} includeContainer add container list to check
+     * @param {IterativeOptions} options
+     * @returns {Array.<Element|CandidatesScope>}
+     */
 
-    var isContentEditable = function isContentEditable(node) {
-      return node.contentEditable === 'true';
-    };
 
-    var getTabindex = function getTabindex(node) {
-      var tabindexAttr = parseInt(node.getAttribute('tabindex'), 10);
+    var getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+      var candidates = [];
+      var elementsToCheck = Array.from(elements);
 
-      if (!isNaN(tabindexAttr)) {
-        return tabindexAttr;
-      } // Browsers do not return `tabIndex` correctly for contentEditable nodes;
-      // so if they don't have a tabindex attribute specifically set, assume it's 0.
+      while (elementsToCheck.length) {
+        var element = elementsToCheck.shift();
 
+        if (element.tagName === 'SLOT') {
+          // add shadow dom slot scope (slot itself cannot be focusable)
+          var assigned = element.assignedElements();
+          var content = assigned.length ? assigned : element.children;
+          var nestedCandidates = getCandidatesIteratively(content, true, options);
 
-      if (isContentEditable(node)) {
-        return 0;
-      } // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default
-      //  `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,
-      //  yet they are still part of the regular tab order; in FF, they get a default
-      //  `tabIndex` of 0; since Chrome still puts those elements in the regular tab
-      //  order, consider their tab index to be 0.
+          if (options.flatten) {
+            candidates.push.apply(candidates, nestedCandidates);
+          } else {
+            candidates.push({
+              scope: element,
+              candidates: nestedCandidates
+            });
+          }
+        } else {
+          // check candidate element
+          var validCandidate = matches.call(element, candidateSelector);
+
+          if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {
+            candidates.push(element);
+          } // iterate over shadow content if possible
+
+
+          var shadowRoot = element.shadowRoot || // check for an undisclosed shadow
+          typeof options.getShadowRoot === 'function' && options.getShadowRoot(element);
+
+          if (shadowRoot) {
+            // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed
+            //  shadow exists, so look at light dom children as fallback BUT create a scope for any
+            //  child candidates found because they're likely slotted elements (elements that are
+            //  children of the web component element (which has the shadow), in the light dom, but
+            //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,
+            //  _after_ we return from this recursive call
+            var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+
+            if (options.flatten) {
+              candidates.push.apply(candidates, _nestedCandidates);
+            } else {
+              candidates.push({
+                scope: element,
+                candidates: _nestedCandidates
+              });
+            }
+          } else {
+            // there's not shadow so just dig into the element's (light dom) children
+            //  __without__ giving the element special scope treatment
+            elementsToCheck.unshift.apply(elementsToCheck, element.children);
+          }
+        }
+      }
 
+      return candidates;
+    };
 
-      if ((node.nodeName === 'AUDIO' || node.nodeName === 'VIDEO' || node.nodeName === 'DETAILS') && node.getAttribute('tabindex') === null) {
-        return 0;
+    var getTabindex = function getTabindex(node, isScope) {
+      if (node.tabIndex < 0) {
+        // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default
+        // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,
+        // yet they are still part of the regular tab order; in FF, they get a default
+        // `tabIndex` of 0; since Chrome still puts those elements in the regular tab
+        // order, consider their tab index to be 0.
+        // Also browsers do not return `tabIndex` correctly for contentEditable nodes;
+        // so if they don't have a tabindex attribute specifically set, assume it's 0.
+        //
+        // isScope is positive for custom element with shadow root or slot that by default
+        // have tabIndex -1, but need to be sorted by document order in order for their
+        // content to be inserted in the correct position
+        if ((isScope || /^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || node.isContentEditable) && isNaN(parseInt(node.getAttribute('tabindex'), 10))) {
+          return 0;
+        }
       }
 
       return node.tabIndex;
@@ -202,8 +295,26 @@
         return true;
       }
 
-      var radioScope = node.form || node.ownerDocument;
-      var radioSet = radioScope.querySelectorAll('input[type="radio"][name="' + node.name + '"]');
+      var radioScope = node.form || getRootNode(node);
+
+      var queryRadios = function queryRadios(name) {
+        return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
+      };
+
+      var radioSet;
+
+      if (typeof window !== 'undefined' && typeof window.CSS !== 'undefined' && typeof window.CSS.escape === 'function') {
+        radioSet = queryRadios(window.CSS.escape(node.name));
+      } else {
+        try {
+          radioSet = queryRadios(node.name);
+        } catch (err) {
+          // eslint-disable-next-line no-console
+          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', err.message);
+          return false;
+        }
+      }
+
       var checked = getCheckedRadio(radioSet, node.form);
       return !checked || checked === node;
     };
@@ -216,7 +327,23 @@
       return isRadio(node) && !isTabbableRadio(node);
     };
 
-    var isHidden = function isHidden(node) {
+    var isZeroArea = function isZeroArea(node) {
+      var _node$getBoundingClie = node.getBoundingClientRect(),
+          width = _node$getBoundingClie.width,
+          height = _node$getBoundingClie.height;
+
+      return width === 0 && height === 0;
+    };
+
+    var isHidden = function isHidden(node, _ref) {
+      var displayCheck = _ref.displayCheck,
+          getShadowRoot = _ref.getShadowRoot;
+
+      // NOTE: visibility will be `undefined` if node is detached from the document
+      //  (see notes about this further down), which means we will consider it visible
+      //  (this is legacy behavior from a very long way back)
+      // NOTE: we check this regardless of `displayCheck="none"` because this is a
+      //  _visibility_ check, not a _display_ check
       if (getComputedStyle(node).visibility === 'hidden') {
         return true;
       }
@@ -226,64 +353,234 @@
 
       if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {
         return true;
-      }
+      } // The root node is the shadow root if the node is in a shadow DOM; some document otherwise
+      //  (but NOT _the_ document; see second 'If' comment below for more).
+      // If rootNode is shadow root, it'll have a host, which is the element to which the shadow
+      //  is attached, and the one we need to check if it's in the document or not (because the
+      //  shadow, and all nodes it contains, is never considered in the document since shadows
+      //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,
+      //  is hidden, or is not in the document itself but is detached, it will affect the shadow's
+      //  visibility, including all the nodes it contains). The host could be any normal node,
+      //  or a custom element (i.e. web component). Either way, that's the one that is considered
+      //  part of the document, not the shadow root, nor any of its children (i.e. the node being
+      //  tested).
+      // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the
+      //  document (per the docs) and while it's a Document-type object, that document does not
+      //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer
+      //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,
+      //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when
+      //  node is actually detached.
+
+
+      var nodeRootHost = getRootNode(node).host;
+      var nodeIsAttached = (nodeRootHost === null || nodeRootHost === void 0 ? void 0 : nodeRootHost.ownerDocument.contains(nodeRootHost)) || node.ownerDocument.contains(node);
+
+      if (!displayCheck || displayCheck === 'full') {
+        if (typeof getShadowRoot === 'function') {
+          // figure out if we should consider the node to be in an undisclosed shadow and use the
+          //  'non-zero-area' fallback
+          var originalNode = node;
+
+          while (node) {
+            var parentElement = node.parentElement;
+            var rootNode = getRootNode(node);
+
+            if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow
+            ) {
+              // node has an undisclosed shadow which means we can only treat it as a black box, so we
+              //  fall back to a non-zero-area test
+              return isZeroArea(node);
+            } else if (node.assignedSlot) {
+              // iterate up slot
+              node = node.assignedSlot;
+            } else if (!parentElement && rootNode !== node.ownerDocument) {
+              // cross shadow boundary
+              node = rootNode.host;
+            } else {
+              // iterate up normal dom
+              node = parentElement;
+            }
+          }
 
-      while (node) {
-        if (getComputedStyle(node).display === 'none') {
-          return true;
+          node = originalNode;
+        } // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support
+        //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or
+        //  it might be a falsy value, which means shadow DOM support is disabled
+        // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)
+        //  now we can just test to see if it would normally be visible or not, provided it's
+        //  attached to the main document.
+        // NOTE: We must consider case where node is inside a shadow DOM and given directly to
+        //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.
+
+
+        if (nodeIsAttached) {
+          // this works wherever the node is: if there's at least one client rect, it's
+          //  somehow displayed; it also covers the CSS 'display: contents' case where the
+          //  node itself is hidden in place of its contents; and there's no need to search
+          //  up the hierarchy either
+          return !node.getClientRects().length;
+        } // Else, the node isn't attached to the document, which means the `getClientRects()`
+        //  API will __always__ return zero rects (this can happen, for example, if React
+        //  is used to render nodes onto a detached tree, as confirmed in this thread:
+        //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)
+        //
+        // It also means that even window.getComputedStyle(node).display will return `undefined`
+        //  because styles are only computed for nodes that are in the document.
+        //
+        // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable
+        //  somehow. Though it was never stated officially, anyone who has ever used tabbable
+        //  APIs on nodes in detached containers has actually implicitly used tabbable in what
+        //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck="none"` mode -- essentially
+        //  considering __everything__ to be visible because of the innability to determine styles.
+
+      } else if (displayCheck === 'non-zero-area') {
+        // NOTE: Even though this tests that the node's client rect is non-zero to determine
+        //  whether it's displayed, and that a detached node will __always__ have a zero-area
+        //  client rect, we don't special-case for whether the node is attached or not. In
+        //  this mode, we do want to consider nodes that have a zero area to be hidden at all
+        //  times, and that includes attached or not.
+        return isZeroArea(node);
+      } // visible, as far as we can tell, or per current `displayCheck` mode
+
+
+      return false;
+    }; // form fields (nested) inside a disabled fieldset are not focusable/tabbable
+    //  unless they are in the _first_ <legend> element of the top-most disabled
+    //  fieldset
+
+
+    var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
+      if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+        var parentNode = node.parentElement; // check if `node` is contained in a disabled <fieldset>
+
+        while (parentNode) {
+          if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {
+            // look for the first <legend> among the children of the disabled <fieldset>
+            for (var i = 0; i < parentNode.children.length; i++) {
+              var child = parentNode.children.item(i); // when the first <legend> (in document order) is found
+
+              if (child.tagName === 'LEGEND') {
+                // if its parent <fieldset> is not nested in another disabled <fieldset>,
+                // return whether `node` is a descendant of its first <legend>
+                return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);
+              }
+            } // the disabled <fieldset> containing `node` has no <legend>
+
+
+            return true;
+          }
+
+          parentNode = parentNode.parentElement;
         }
+      } // else, node's tabbable/focusable state should not be affected by a fieldset's
+      //  enabled/disabled state
 
-        node = node.parentElement;
-      }
 
       return false;
     };
 
-    var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(node) {
-      if (node.disabled || isHiddenInput(node) || isHidden(node) ||
-      /* For a details element with a summary, the summary element gets the focused  */
-      isDetailsWithSummary(node)) {
+    var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
+      if (node.disabled || isHiddenInput(node) || isHidden(node, options) || // For a details element with a summary, the summary element gets the focus
+      isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
         return false;
       }
 
       return true;
     };
 
-    var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(node) {
-      if (!isNodeMatchingSelectorFocusable(node) || isNonTabbableRadio(node) || getTabindex(node) < 0) {
+    var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
+      if (isNonTabbableRadio(node) || getTabindex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
         return false;
       }
 
       return true;
     };
+    /**
+     * @param {Array.<Element|CandidatesScope>} candidates
+     * @returns Element[]
+     */
 
-    var tabbable = function tabbable(el, options) {
-      options = options || {};
+
+    var sortByOrder = function sortByOrder(candidates) {
       var regularTabbables = [];
       var orderedTabbables = [];
-      var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable);
-      candidates.forEach(function (candidate, i) {
-        var candidateTabindex = getTabindex(candidate);
+      candidates.forEach(function (item, i) {
+        var isScope = !!item.scope;
+        var element = isScope ? item.scope : item;
+        var candidateTabindex = getTabindex(element, isScope);
+        var elements = isScope ? sortByOrder(item.candidates) : element;
 
         if (candidateTabindex === 0) {
-          regularTabbables.push(candidate);
+          isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
         } else {
           orderedTabbables.push({
             documentOrder: i,
             tabIndex: candidateTabindex,
-            node: candidate
+            item: item,
+            isScope: isScope,
+            content: elements
           });
         }
       });
-      var tabbableNodes = orderedTabbables.sort(sortOrderedTabbables).map(function (a) {
-        return a.node;
-      }).concat(regularTabbables);
-      return tabbableNodes;
+      return orderedTabbables.sort(sortOrderedTabbables).reduce(function (acc, sortable) {
+        sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+        return acc;
+      }, []).concat(regularTabbables);
+    };
+
+    var tabbable = function tabbable(el, options) {
+      options = options || {};
+      var candidates;
+
+      if (options.getShadowRoot) {
+        candidates = getCandidatesIteratively([el], options.includeContainer, {
+          filter: isNodeMatchingSelectorTabbable.bind(null, options),
+          flatten: false,
+          getShadowRoot: options.getShadowRoot
+        });
+      } else {
+        candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+      }
+
+      return sortByOrder(candidates);
+    };
+
+    var focusable = function focusable(el, options) {
+      options = options || {};
+      var candidates;
+
+      if (options.getShadowRoot) {
+        candidates = getCandidatesIteratively([el], options.includeContainer, {
+          filter: isNodeMatchingSelectorFocusable.bind(null, options),
+          flatten: true,
+          getShadowRoot: options.getShadowRoot
+        });
+      } else {
+        candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+      }
+
+      return candidates;
+    };
+
+    var isTabbable = function isTabbable(node, options) {
+      options = options || {};
+
+      if (!node) {
+        throw new Error('No node provided');
+      }
+
+      if (matches.call(node, candidateSelector) === false) {
+        return false;
+      }
+
+      return isNodeMatchingSelectorTabbable(options, node);
     };
 
     var focusableCandidateSelector = /* #__PURE__ */candidateSelectors.concat('iframe').join(',');
 
-    var isFocusable = function isFocusable(node) {
+    var isFocusable = function isFocusable(node, options) {
+      options = options || {};
+
       if (!node) {
         throw new Error('No node provided');
       }
@@ -292,38 +589,22 @@
         return false;
       }
 
-      return isNodeMatchingSelectorFocusable(node);
+      return isNodeMatchingSelectorFocusable(options, node);
     };
 
     /*!
-    * focus-trap 6.2.2
+    * focus-trap 6.9.2
     * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
     */
 
-    function _defineProperty$1(obj, key, value) {
-      if (key in obj) {
-        Object.defineProperty(obj, key, {
-          value: value,
-          enumerable: true,
-          configurable: true,
-          writable: true
-        });
-      } else {
-        obj[key] = value;
-      }
-
-      return obj;
-    }
-
     function ownKeys(object, enumerableOnly) {
       var keys = Object.keys(object);
 
       if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) symbols = symbols.filter(function (sym) {
+        enumerableOnly && (symbols = symbols.filter(function (sym) {
           return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-        });
-        keys.push.apply(keys, symbols);
+        })), keys.push.apply(keys, symbols);
       }
 
       return keys;
@@ -331,25 +612,31 @@
 
     function _objectSpread2(target) {
       for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i] != null ? arguments[i] : {};
-
-        if (i % 2) {
-          ownKeys(Object(source), true).forEach(function (key) {
-            _defineProperty$1(target, key, source[key]);
-          });
-        } else if (Object.getOwnPropertyDescriptors) {
-          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-        } else {
-          ownKeys(Object(source)).forEach(function (key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-          });
-        }
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+          _defineProperty$1(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
       }
 
       return target;
     }
 
-    var activeFocusDelay;
+    function _defineProperty$1(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, {
+          value: value,
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      } else {
+        obj[key] = value;
+      }
+
+      return obj;
+    }
 
     var activeFocusTraps = function () {
       var trapQueue = [];
@@ -401,10 +688,54 @@
 
     var delay = function delay(fn) {
       return setTimeout(fn, 0);
+    }; // Array.find/findIndex() are not supported on IE; this replicates enough
+    //  of Array.findIndex() for our needs
+
+
+    var findIndex = function findIndex(arr, fn) {
+      var idx = -1;
+      arr.every(function (value, i) {
+        if (fn(value)) {
+          idx = i;
+          return false; // break
+        }
+
+        return true; // next
+      });
+      return idx;
+    };
+    /**
+     * Get an option's value when it could be a plain value, or a handler that provides
+     *  the value.
+     * @param {*} value Option's value to check.
+     * @param {...*} [params] Any parameters to pass to the handler, if `value` is a function.
+     * @returns {*} The `value`, or the handler's returned value.
+     */
+
+
+    var valueOrHandler = function valueOrHandler(value) {
+      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        params[_key - 1] = arguments[_key];
+      }
+
+      return typeof value === 'function' ? value.apply(void 0, params) : value;
+    };
+
+    var getActualTarget = function getActualTarget(event) {
+      // NOTE: If the trap is _inside_ a shadow DOM, event.target will always be the
+      //  shadow host. However, event.target.composedPath() will be an array of
+      //  nodes "clicked" from inner-most (the actual element inside the shadow) to
+      //  outer-most (the host HTML document). If we have access to composedPath(),
+      //  then use its first element; otherwise, fall back to event.target (and
+      //  this only works for an _open_ shadow DOM; otherwise,
+      //  composedPath()[0] === event.target always).
+      return event.target.shadowRoot && typeof event.composedPath === 'function' ? event.composedPath()[0] : event.target;
     };
 
     var createFocusTrap = function createFocusTrap(elements, userOptions) {
-      var doc = document;
+      // SSR: a live trap shouldn't be created in this type of environment so this
+      //  should be safe code to execute if the `document` option isn't specified
+      var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;
 
       var config = _objectSpread2({
         returnFocusOnDeactivate: true,
@@ -413,51 +744,122 @@
       }, userOptions);
 
       var state = {
+        // containers given to createFocusTrap()
         // @type {Array<HTMLElement>}
         containers: [],
-        // list of objects identifying the first and last tabbable nodes in all containers/groups in
-        //  the trap
+        // 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<{ firstTabbableNode: HTMLElement|null, lastTabbableNode: HTMLElement|null }>}
+        // @type {Array<{
+        //   container: HTMLElement,
+        //   tabbableNodes: Array<HTMLElement>, // empty if none
+        //   focusableNodes: Array<HTMLElement>, // empty if none
+        //   firstTabbableNode: HTMLElement|null,
+        //   lastTabbableNode: HTMLElement|null,
+        //   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: false,
-        paused: false
+        paused: false,
+        // timer ID for when delayInitialFocus is true and initial focus in this trap
+        //  has been delayed during activation
+        delayInitialFocusTimer: undefined
       };
       var trap; // eslint-disable-line prefer-const -- some private functions reference it, and its methods reference private functions, so we must declare here and define later
 
-      var containersContain = function containersContain(element) {
-        return state.containers.some(function (container) {
-          return container.contains(element);
+      /**
+       * Gets a configuration option value.
+       * @param {Object|undefined} configOverrideOptions If true, and option is defined in this set,
+       *  value will be taken from this object. Otherwise, value will be taken from base configuration.
+       * @param {string} optionName Name of the option whose value is sought.
+       * @param {string|undefined} [configOptionName] Name of option to use __instead of__ `optionName`
+       *  IIF `configOverrideOptions` is not defined. Otherwise, `optionName` is used.
+       */
+
+      var getOption = function getOption(configOverrideOptions, optionName, configOptionName) {
+        return configOverrideOptions && configOverrideOptions[optionName] !== undefined ? configOverrideOptions[optionName] : config[configOptionName || optionName];
+      };
+      /**
+       * Finds the index of the container that contains the element.
+       * @param {HTMLElement} element
+       * @returns {number} Index of the container in either `state.containers` or
+       *  `state.containerGroups` (the order/length of these lists are the same); -1
+       *  if the element isn't found.
+       */
+
+
+      var findContainerIndex = function findContainerIndex(element) {
+        // NOTE: search `containerGroups` because it's possible a group contains no tabbable
+        //  nodes, but still contains focusable nodes (e.g. if they all have `tabindex=-1`)
+        //  and we still need to find the element in there
+        return state.containerGroups.findIndex(function (_ref) {
+          var container = _ref.container,
+              tabbableNodes = _ref.tabbableNodes;
+          return container.contains(element) || // 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)
+          tabbableNodes.find(function (node) {
+            return node === element;
+          });
         });
       };
+      /**
+       * Gets the node for the given option, which is expected to be an option that
+       *  can be either a DOM node, a string that is a selector to get a node, `false`
+       *  (if a node is explicitly NOT given), or a function that returns any of these
+       *  values.
+       * @param {string} optionName
+       * @returns {undefined | false | HTMLElement | SVGElement} Returns
+       *  `undefined` if the option is not specified; `false` if the option
+       *  resolved to `false` (node explicitly not given); otherwise, the resolved
+       *  DOM node.
+       * @throws {Error} If the option is set, not `false`, and is not, or does not
+       *  resolve to a node.
+       */
+
 
       var getNodeForOption = function getNodeForOption(optionName) {
         var optionValue = config[optionName];
 
-        if (!optionValue) {
-          return null;
+        if (typeof optionValue === 'function') {
+          for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            params[_key2 - 1] = arguments[_key2];
+          }
+
+          optionValue = optionValue.apply(void 0, params);
         }
 
-        var node = optionValue;
+        if (optionValue === true) {
+          optionValue = undefined; // use default value
+        }
 
-        if (typeof optionValue === 'string') {
-          node = doc.querySelector(optionValue);
+        if (!optionValue) {
+          if (optionValue === undefined || optionValue === false) {
+            return optionValue;
+          } // else, empty string (invalid), null (invalid), 0 (invalid)
 
-          if (!node) {
-            throw new Error("`".concat(optionName, "` refers to no known node"));
-          }
+
+          throw new Error("`".concat(optionName, "` was specified but was not a node, or did not return a node"));
         }
 
-        if (typeof optionValue === 'function') {
-          node = optionValue();
+        var node = optionValue; // could be HTMLElement, SVGElement, or non-empty string at this point
+
+        if (typeof optionValue === 'string') {
+          node = doc.querySelector(optionValue); // resolve to node, or null if fails
 
           if (!node) {
-            throw new Error("`".concat(optionName, "` did not return a node"));
+            throw new Error("`".concat(optionName, "` as selector refers to no known node"));
           }
         }
 
@@ -465,16 +867,22 @@
       };
 
       var getInitialFocusNode = function getInitialFocusNode() {
-        var node;
+        var node = getNodeForOption('initialFocus'); // false explicitly indicates we want no initialFocus at all
 
-        if (getNodeForOption('initialFocus') !== null) {
-          node = getNodeForOption('initialFocus');
-        } else if (containersContain(doc.activeElement)) {
-          node = doc.activeElement;
-        } else {
-          var firstTabbableGroup = state.tabbableGroups[0];
-          var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
-          node = firstTabbableNode || getNodeForOption('fallbackFocus');
+        if (node === false) {
+          return false;
+        }
+
+        if (node === undefined) {
+          // option not specified: use fallback options
+          if (findContainerIndex(doc.activeElement) >= 0) {
+            node = doc.activeElement;
+          } else {
+            var firstTabbableGroup = state.tabbableGroups[0];
+            var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode; // NOTE: `fallbackFocus` option function cannot return `false` (not supported)
+
+            node = firstTabbableNode || getNodeForOption('fallbackFocus');
+          }
         }
 
         if (!node) {
@@ -485,28 +893,73 @@
       };
 
       var updateTabbableNodes = function updateTabbableNodes() {
-        state.tabbableGroups = state.containers.map(function (container) {
-          var tabbableNodes = tabbable(container);
+        state.containerGroups = state.containers.map(function (container) {
+          var tabbableNodes = tabbable(container, config.tabbableOptions); // NOTE: if we have tabbable nodes, we must have focusable nodes; focusable nodes
+          //  are a superset of tabbable nodes
+
+          var focusableNodes = focusable(container, config.tabbableOptions);
+          return {
+            container: container,
+            tabbableNodes: tabbableNodes,
+            focusableNodes: focusableNodes,
+            firstTabbableNode: tabbableNodes.length > 0 ? tabbableNodes[0] : null,
+            lastTabbableNode: tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : null,
 
-          if (tabbableNodes.length > 0) {
-            return {
-              firstTabbableNode: tabbableNodes[0],
-              lastTabbableNode: tabbableNodes[tabbableNodes.length - 1]
-            };
-          }
+            /**
+             * 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 nextTabbableNode(node) {
+              var forward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+              // NOTE: If tabindex is positive (in order to manipulate the tab order separate
+              //  from the DOM order), this __will not work__ because the list of focusableNodes,
+              //  while it contains tabbable nodes, does not sort its nodes in any order other
+              //  than DOM order, because it can't: Where would you place focusable (but not
+              //  tabbable) nodes in that order? They have no order, because they aren't tabbale...
+              // Support for positive tabindex is already broken and hard to manage (possibly
+              //  not supportable, TBD), so this isn't going to make things worse than they
+              //  already are, and at least makes things better for the majority of cases where
+              //  tabindex is either 0/unset or negative.
+              // FYI, positive tabindex issue: https://github.com/focus-trap/focus-trap/issues/375
+              var nodeIdx = focusableNodes.findIndex(function (n) {
+                return n === node;
+              });
+
+              if (nodeIdx < 0) {
+                return undefined;
+              }
 
-          return undefined;
-        }).filter(function (group) {
-          return !!group;
-        }); // remove groups with no tabbable nodes
-        // throw if no groups have tabbable nodes and we don't have a fallback focus node either
+              if (forward) {
+                return focusableNodes.slice(nodeIdx + 1).find(function (n) {
+                  return isTabbable(n, config.tabbableOptions);
+                });
+              }
+
+              return focusableNodes.slice(0, nodeIdx).reverse().find(function (n) {
+                return isTabbable(n, config.tabbableOptions);
+              });
+            }
+          };
+        });
+        state.tabbableGroups = state.containerGroups.filter(function (group) {
+          return group.tabbableNodes.length > 0;
+        }); // throw if no groups have tabbable nodes and we don't have a fallback focus node either
 
-        if (state.tabbableGroups.length <= 0 && !getNodeForOption('fallbackFocus')) {
+        if (state.tabbableGroups.length <= 0 && !getNodeForOption('fallbackFocus') // returning false not supported for this option
+        ) {
           throw new Error('Your focus-trap must have at least one container with at least one tabbable node in it at all times');
         }
       };
 
       var tryFocus = function tryFocus(node) {
+        if (node === false) {
+          return;
+        }
+
         if (node === doc.activeElement) {
           return;
         }
@@ -527,19 +980,21 @@
       };
 
       var getReturnFocusNode = function getReturnFocusNode(previousActiveElement) {
-        var node = getNodeForOption('setReturnFocus');
-        return node ? node : previousActiveElement;
+        var node = getNodeForOption('setReturnFocus', previousActiveElement);
+        return node ? node : node === false ? false : previousActiveElement;
       }; // This needs to be done on mousedown and touchstart instead of click
       // so that it precedes the focus event.
 
 
       var checkPointerDown = function checkPointerDown(e) {
-        if (containersContain(e.target)) {
+        var target = getActualTarget(e);
+
+        if (findContainerIndex(target) >= 0) {
           // allow the click since it ocurred inside the trap
           return;
         }
 
-        if (config.clickOutsideDeactivates) {
+        if (valueOrHandler(config.clickOutsideDeactivates, e)) {
           // immediately deactivate the trap
           trap.deactivate({
             // if, on deactivation, we should return focus to the node originally-focused
@@ -553,7 +1008,7 @@
             //  that was clicked, whether it's focusable or not; by setting
             //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused
             //  on activation (or the configured `setReturnFocus` node)
-            returnFocus: config.returnFocusOnDeactivate && !isFocusable(e.target)
+            returnFocus: config.returnFocusOnDeactivate && !isFocusable(target, config.tabbableOptions)
           });
           return;
         } // This is needed for mobile devices.
@@ -561,7 +1016,7 @@
         // then on mobile they will be blocked anyways if `touchstart` is blocked.)
 
 
-        if (config.allowOutsideClick && (typeof config.allowOutsideClick === 'boolean' ? config.allowOutsideClick : config.allowOutsideClick(e))) {
+        if (valueOrHandler(config.allowOutsideClick, e)) {
           // allow the click outside the trap to take place
           return;
         } // otherwise, prevent the click
@@ -572,11 +1027,12 @@
 
 
       var checkFocusIn = function checkFocusIn(e) {
-        var targetContained = containersContain(e.target); // In Firefox when you Tab out of an iframe the Document is briefly focused.
+        var target = getActualTarget(e);
+        var targetContained = findContainerIndex(target) >= 0; // In Firefox when you Tab out of an iframe the Document is briefly focused.
 
-        if (targetContained || e.target instanceof Document) {
+        if (targetContained || target instanceof Document) {
           if (targetContained) {
-            state.mostRecentlyFocusedNode = e.target;
+            state.mostRecentlyFocusedNode = target;
           }
         } else {
           // escaped! pull it back in to where it just left
@@ -590,28 +1046,75 @@
 
 
       var checkTab = function checkTab(e) {
+        var target = getActualTarget(e);
         updateTabbableNodes();
         var destinationNode = null;
 
         if (state.tabbableGroups.length > 0) {
-          if (e.shiftKey) {
-            var startOfGroupIndex = state.tabbableGroups.findIndex(function (_ref) {
-              var firstTabbableNode = _ref.firstTabbableNode;
-              return e.target === firstTabbableNode;
+          // make sure the target is actually contained in a group
+          // NOTE: the target may also be the container itself if it's focusable
+          //  with tabIndex='-1' and was given initial focus
+          var containerIndex = findContainerIndex(target);
+          var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : undefined;
+
+          if (containerIndex < 0) {
+            // target not found in any group: quite possible focus has escaped the trap,
+            //  so bring it back in to...
+            if (e.shiftKey) {
+              // ...the last node in the last group
+              destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;
+            } else {
+              // ...the first node in the first group
+              destinationNode = state.tabbableGroups[0].firstTabbableNode;
+            }
+          } else if (e.shiftKey) {
+            // REVERSE
+            // is the target the first tabbable node in a group?
+            var startOfGroupIndex = findIndex(state.tabbableGroups, function (_ref2) {
+              var firstTabbableNode = _ref2.firstTabbableNode;
+              return target === firstTabbableNode;
             });
 
+            if (startOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {
+              // an exception case where the target is either the container itself, or
+              //  a non-tabbable node that was given focus (i.e. tabindex is negative
+              //  and user clicked on it or node was programmatically given focus)
+              //  and is not followed by any other tabbable node, in which
+              //  case, we should handle shift+tab as if focus were on the container's
+              //  first tabbable node, and go to the last tabbable node of the LAST group
+              startOfGroupIndex = containerIndex;
+            }
+
             if (startOfGroupIndex >= 0) {
+              // YES: then shift+tab should go to the last tabbable node in the
+              //  previous group (and wrap around to the last tabbable node of
+              //  the LAST group if it's the first tabbable node of the FIRST group)
               var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
               var destinationGroup = state.tabbableGroups[destinationGroupIndex];
               destinationNode = destinationGroup.lastTabbableNode;
             }
           } else {
-            var lastOfGroupIndex = state.tabbableGroups.findIndex(function (_ref2) {
-              var lastTabbableNode = _ref2.lastTabbableNode;
-              return e.target === lastTabbableNode;
+            // FORWARD
+            // is the target the last tabbable node in a group?
+            var lastOfGroupIndex = findIndex(state.tabbableGroups, function (_ref3) {
+              var lastTabbableNode = _ref3.lastTabbableNode;
+              return target === lastTabbableNode;
             });
 
+            if (lastOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {
+              // an exception case where the target is the container itself, or
+              //  a non-tabbable node that was given focus (i.e. tabindex is negative
+              //  and user clicked on it or node was programmatically given focus)
+              //  and is not followed by any other tabbable node, in which
+              //  case, we should handle tab as if focus were on the container's
+              //  last tabbable node, and go to the first tabbable node of the FIRST group
+              lastOfGroupIndex = containerIndex;
+            }
+
             if (lastOfGroupIndex >= 0) {
+              // YES: then tab should go to the first tabbable node in the next
+              //  group (and wrap around to the first tabbable node of the FIRST
+              //  group if it's the last tabbable node of the LAST group)
               var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
 
               var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];
@@ -619,17 +1122,19 @@
             }
           }
         } else {
+          // NOTE: the fallbackFocus option does not support returning false to opt-out
           destinationNode = getNodeForOption('fallbackFocus');
         }
 
         if (destinationNode) {
           e.preventDefault();
           tryFocus(destinationNode);
-        }
+        } // else, let the browser take care of [shift+]tab and move the focus
+
       };
 
       var checkKey = function checkKey(e) {
-        if (config.escapeDeactivates !== false && isEscapeEvent(e)) {
+        if (isEscapeEvent(e) && valueOrHandler(config.escapeDeactivates, e) !== false) {
           e.preventDefault();
           trap.deactivate();
           return;
@@ -642,15 +1147,17 @@
       };
 
       var checkClick = function checkClick(e) {
-        if (config.clickOutsideDeactivates) {
+        var target = getActualTarget(e);
+
+        if (findContainerIndex(target) >= 0) {
           return;
         }
 
-        if (containersContain(e.target)) {
+        if (valueOrHandler(config.clickOutsideDeactivates, e)) {
           return;
         }
 
-        if (config.allowOutsideClick && (typeof config.allowOutsideClick === 'boolean' ? config.allowOutsideClick : config.allowOutsideClick(e))) {
+        if (valueOrHandler(config.allowOutsideClick, e)) {
           return;
         }
 
@@ -670,7 +1177,7 @@
         activeFocusTraps.activateTrap(trap); // Delay ensures that the focused element doesn't capture the event
         // that caused the focus trap activation.
 
-        activeFocusDelay = config.delayInitialFocus ? delay(function () {
+        state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function () {
           tryFocus(getInitialFocusNode());
         }) : tryFocus(getInitialFocusNode());
         doc.addEventListener('focusin', checkFocusIn, true);
@@ -710,22 +1217,53 @@
 
 
       trap = {
+        get active() {
+          return state.active;
+        },
+
+        get paused() {
+          return state.paused;
+        },
+
         activate: function activate(activateOptions) {
           if (state.active) {
             return this;
           }
 
-          updateTabbableNodes();
+          var onActivate = getOption(activateOptions, 'onActivate');
+          var onPostActivate = getOption(activateOptions, 'onPostActivate');
+          var checkCanFocusTrap = getOption(activateOptions, 'checkCanFocusTrap');
+
+          if (!checkCanFocusTrap) {
+            updateTabbableNodes();
+          }
+
           state.active = true;
           state.paused = false;
           state.nodeFocusedBeforeActivation = doc.activeElement;
-          var onActivate = activateOptions && activateOptions.onActivate ? activateOptions.onActivate : config.onActivate;
 
           if (onActivate) {
             onActivate();
           }
 
-          addListeners();
+          var finishActivation = function finishActivation() {
+            if (checkCanFocusTrap) {
+              updateTabbableNodes();
+            }
+
+            addListeners();
+
+            if (onPostActivate) {
+              onPostActivate();
+            }
+          };
+
+          if (checkCanFocusTrap) {
+            checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
+            return this;
+          }
+
+          finishActivation();
           return this;
         },
         deactivate: function deactivate(deactivateOptions) {
@@ -733,25 +1271,46 @@
             return this;
           }
 
-          clearTimeout(activeFocusDelay);
+          var options = _objectSpread2({
+            onDeactivate: config.onDeactivate,
+            onPostDeactivate: config.onPostDeactivate,
+            checkCanReturnFocus: config.checkCanReturnFocus
+          }, deactivateOptions);
+
+          clearTimeout(state.delayInitialFocusTimer); // noop if undefined
+
+          state.delayInitialFocusTimer = undefined;
           removeListeners();
           state.active = false;
           state.paused = false;
           activeFocusTraps.deactivateTrap(trap);
-          var onDeactivate = deactivateOptions && deactivateOptions.onDeactivate !== undefined ? deactivateOptions.onDeactivate : config.onDeactivate;
+          var onDeactivate = getOption(options, 'onDeactivate');
+          var onPostDeactivate = getOption(options, 'onPostDeactivate');
+          var checkCanReturnFocus = getOption(options, 'checkCanReturnFocus');
+          var returnFocus = getOption(options, 'returnFocus', 'returnFocusOnDeactivate');
 
           if (onDeactivate) {
             onDeactivate();
           }
 
-          var returnFocus = deactivateOptions && deactivateOptions.returnFocus !== undefined ? deactivateOptions.returnFocus : config.returnFocusOnDeactivate;
-
-          if (returnFocus) {
+          var finishDeactivation = function finishDeactivation() {
             delay(function () {
-              tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
+              if (returnFocus) {
+                tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
+              }
+
+              if (onPostDeactivate) {
+                onPostDeactivate();
+              }
             });
+          };
+
+          if (returnFocus && checkCanReturnFocus) {
+            checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
+            return this;
           }
 
+          finishDeactivation();
           return this;
         },
         pause: function pause() {
@@ -3852,7 +4411,7 @@
             return null;
         }
         return (React__namespace.createElement(Backdrop, null,
-            React__namespace.createElement(FocusTrap, { active: !disableFocusTrap, focusTrapOptions: { clickOutsideDeactivates: true }, className: css(styles$1h.bullseye) },
+            React__namespace.createElement(FocusTrap, { active: !disableFocusTrap, focusTrapOptions: { clickOutsideDeactivates: true, tabbableOptions: { displayCheck: 'none' } }, className: css(styles$1h.bullseye) },
                 React__namespace.createElement(AboutModalBox, { className: className, "aria-labelledby": aboutModalBoxHeaderId, "aria-describedby": aboutModalBoxContentId },
                     React__namespace.createElement(AboutModalBoxBrand, { src: brandImageSrc, alt: brandImageAlt }),
                     React__namespace.createElement(AboutModalBoxCloseButton, { "aria-label": closeButtonAriaLabel, onClose: onClose }),
@@ -8522,6 +9081,7 @@
         const content = (React__namespace.createElement(FocusTrap, Object.assign({ active: focusTrapActive, focusTrapOptions: {
                 returnFocusOnDeactivate: true,
                 clickOutsideDeactivates: true,
+                tabbableOptions: { displayCheck: 'none' },
                 fallbackFocus: () => {
                     // If the popover's trigger is focused but scrolled out of view,
                     // FocusTrap will throw an error when the Enter button is used on the trigger.
@@ -9068,7 +9628,7 @@
             const screenReaderLabelId = `pf-context-selector-label-id-${newId}`;
             const searchButtonId = `pf-context-selector-search-button-id-${newId}`;
             const _a = this.props, { children, className, isOpen, isFullHeight, onToggle, onSelect, screenReaderLabel, toggleText, searchButtonAriaLabel, searchInputValue, onSearchInputChange, searchInputPlaceholder, onSearchButtonClick, menuAppendTo, ouiaId, ouiaSafe, isPlain, isText, footer, disableFocusTrap, isFlipEnabled } = _a, props = __rest$1(_a, ["children", "className", "isOpen", "isFullHeight", "onToggle", "onSelect", "screenReaderLabel", "toggleText", "searchButtonAriaLabel", "searchInputValue", "onSearchInputChange", "searchInputPlaceholder", "onSearchButtonClick", "menuAppendTo", "ouiaId", "ouiaSafe", "isPlain", "isText", "footer", "disableFocusTrap", "isFlipEnabled"]);
-            const menuContainer = (React__namespace.createElement("div", Object.assign({ className: css(styles$Q.contextSelectorMenu) }, (isFlipEnabled && { style: { position: 'revert' } })), isOpen && (React__namespace.createElement(FocusTrap, { active: !disableFocusTrap, focusTrapOptions: { clickOutsideDeactivates: true } },
+            const menuContainer = (React__namespace.createElement("div", Object.assign({ className: css(styles$Q.contextSelectorMenu) }, (isFlipEnabled && { style: { position: 'revert' } })), isOpen && (React__namespace.createElement(FocusTrap, { active: !disableFocusTrap, focusTrapOptions: { clickOutsideDeactivates: true, tabbableOptions: { displayCheck: 'none' } } },
                 React__namespace.createElement("div", { className: css(styles$Q.contextSelectorMenuSearch) },
                     React__namespace.createElement(InputGroup, null,
                         React__namespace.createElement(TextInput, { value: searchInputValue, type: "search", placeholder: searchInputPlaceholder, onChange: onSearchInputChange, onKeyPress: this.onEnterPressed, "aria-labelledby": searchButtonId }),
@@ -15433,7 +15993,7 @@
             modalBody,
             modalBoxFooter));
         return (React__namespace.createElement(Backdrop, null,
-            React__namespace.createElement(FocusTrap, { active: !disableFocusTrap, focusTrapOptions: { clickOutsideDeactivates: true }, className: css(styles$1h.bullseye) }, modalBox)));
+            React__namespace.createElement(FocusTrap, { active: !disableFocusTrap, focusTrapOptions: { clickOutsideDeactivates: true, tabbableOptions: { displayCheck: 'none' } }, className: css(styles$1h.bullseye) }, modalBox)));
     };
     ModalContent.displayName = 'ModalContent';