{"version":3,"file":"index.js","sources":["../src/index.js"],"sourcesContent":["// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\nconst candidateSelectors = [\n  'input:not([inert]):not([inert] *)',\n  'select:not([inert]):not([inert] *)',\n  'textarea:not([inert]):not([inert] *)',\n  'a[href]:not([inert]):not([inert] *)',\n  'button:not([inert]):not([inert] *)',\n  '[tabindex]:not(slot):not([inert]):not([inert] *)',\n  'audio[controls]:not([inert]):not([inert] *)',\n  'video[controls]:not([inert]):not([inert] *)',\n  '[contenteditable]:not([contenteditable=\"false\"]):not([inert]):not([inert] *)',\n  'details>summary:first-of-type:not([inert]):not([inert] *)',\n  'details:not([inert]):not([inert] *)',\n];\nconst candidateSelector = /* #__PURE__ */ candidateSelectors.join(',');\n\nconst NoElement = typeof Element === 'undefined';\n\nconst matches = NoElement\n  ? function () {}\n  : Element.prototype.matches ||\n    Element.prototype.msMatchesSelector ||\n    Element.prototype.webkitMatchesSelector;\n\nconst getRootNode =\n  !NoElement && Element.prototype.getRootNode\n    ? (element) => element?.getRootNode?.()\n    : (element) => element?.ownerDocument;\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Node} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nconst isInert = function (node, lookUp = true) {\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  const inertAtt = node?.getAttribute?.('inert');\n  const inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  const result =\n    inert ||\n    (lookUp &&\n      node &&\n      // closest does not exist on shadow roots, so we fall back to a manual\n      // lookup upward, in case it is not defined.\n      (typeof node.closest === 'function'\n        ? node.closest('[inert]')\n        : isInert(node.parentNode)));\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nconst isContentEditable = function (node) {\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  const attValue = node?.getAttribute?.('contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nconst getCandidates = function (el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert (either by itself or via its parent), then all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n\n  let candidates = Array.prototype.slice.apply(\n    el.querySelectorAll(candidateSelector)\n  );\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nconst getCandidatesIteratively = function (\n  elements,\n  includeContainer,\n  options\n) {\n  const candidates = [];\n  const elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    const element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      const assigned = element.assignedElements();\n      const content = assigned.length ? assigned : element.children;\n      const nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push(...nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates,\n        });\n      }\n    } else {\n      // check candidate element\n      const validCandidate = matches.call(element, candidateSelector);\n      if (\n        validCandidate &&\n        options.filter(element) &&\n        (includeContainer || !elements.includes(element))\n      ) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      const shadowRoot =\n        element.shadowRoot ||\n        // check for an undisclosed shadow\n        (typeof options.getShadowRoot === 'function' &&\n          options.getShadowRoot(element));\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      const validShadowRoot =\n        !isInert(shadowRoot, false) &&\n        (!options.shadowRootFilter || options.shadowRootFilter(element));\n\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        const nestedCandidates = getCandidatesIteratively(\n          shadowRoot === true ? element.children : shadowRoot.children,\n          true,\n          options\n        );\n\n        if (options.flatten) {\n          candidates.push(...nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: nestedCandidates,\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift(...element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nconst hasTabIndex = function (node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nconst getTabIndex = function (node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if (\n      (/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) ||\n        isContentEditable(node)) &&\n      !hasTabIndex(node)\n    ) {\n      return 0;\n    }\n  }\n\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nconst getSortOrderTabIndex = function (node, isScope) {\n  const tabIndex = getTabIndex(node);\n\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n\n  return tabIndex;\n};\n\nconst sortOrderedTabbables = function (a, b) {\n  return a.tabIndex === b.tabIndex\n    ? a.documentOrder - b.documentOrder\n    : a.tabIndex - b.tabIndex;\n};\n\nconst isInput = function (node) {\n  return node.tagName === 'INPUT';\n};\n\nconst isHiddenInput = function (node) {\n  return isInput(node) && node.type === 'hidden';\n};\n\nconst isDetailsWithSummary = function (node) {\n  const r =\n    node.tagName === 'DETAILS' &&\n    Array.prototype.slice\n      .apply(node.children)\n      .some((child) => child.tagName === 'SUMMARY');\n  return r;\n};\n\nconst getCheckedRadio = function (nodes, form) {\n  for (let i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\n\nconst isTabbableRadio = function (node) {\n  if (!node.name) {\n    return true;\n  }\n  const radioScope = node.form || getRootNode(node);\n  const queryRadios = function (name) {\n    return radioScope.querySelectorAll(\n      'input[type=\"radio\"][name=\"' + name + '\"]'\n    );\n  };\n\n  let radioSet;\n  if (\n    typeof window !== 'undefined' &&\n    typeof window.CSS !== 'undefined' &&\n    typeof window.CSS.escape === 'function'\n  ) {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error(\n        'Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s',\n        err.message\n      );\n      return false;\n    }\n  }\n\n  const checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\n\nconst isRadio = function (node) {\n  return isInput(node) && node.type === 'radio';\n};\n\nconst isNonTabbableRadio = function (node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nconst isNodeAttached = function (node) {\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  let nodeRoot = node && getRootNode(node);\n  let nodeRootHost = nodeRoot?.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  let attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    attached = !!(\n      nodeRootHost?.ownerDocument?.contains(nodeRootHost) ||\n      node?.ownerDocument?.contains(node)\n    );\n\n    while (!attached && nodeRootHost) {\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = nodeRoot?.host;\n      attached = !!nodeRootHost?.ownerDocument?.contains(nodeRootHost);\n    }\n  }\n\n  return attached;\n};\n\nconst isZeroArea = function (node) {\n  const { width, height } = node.getBoundingClientRect();\n  return width === 0 && height === 0;\n};\nconst isHidden = function (node, { displayCheck, getShadowRoot }) {\n  if (displayCheck === 'full-native') {\n    if ('checkVisibility' in node) {\n      // Chrome >= 105, Edge >= 105, Firefox >= 106, Safari >= 17.4\n      // @see https://developer.mozilla.org/en-US/docs/Web/API/Element/checkVisibility#browser_compatibility\n      const visible = node.checkVisibility({\n        // Checking opacity might be desirable for some use cases, but natively,\n        // opacity zero elements _are_ focusable and tabbable.\n        checkOpacity: false,\n        opacityProperty: false,\n\n        contentVisibilityAuto: true,\n        visibilityProperty: true,\n        // This is an alias for `visibilityProperty`. Contemporary browsers\n        // support both. However, this alias has wider browser support (Chrome\n        // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so\n        // we include it anyway.\n        checkVisibilityCSS: true,\n      });\n      return !visible;\n    }\n    // Fall through to manual visibility checks\n  }\n\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n\n  const isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  const nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n\n  if (\n    !displayCheck ||\n    displayCheck === 'full' ||\n    // full-native can run this branch when it falls through in case\n    // Element#checkVisibility is unsupported\n    displayCheck === 'full-native' ||\n    displayCheck === 'legacy-full'\n  ) {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      const originalNode = node;\n      while (node) {\n        const parentElement = node.parentElement;\n        const rootNode = getRootNode(node);\n        if (\n          parentElement &&\n          !parentElement.shadowRoot &&\n          getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nconst isDisabledFromFieldset = function (node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    let parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (let i = 0; i < parentNode.children.length; i++) {\n          const child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *')\n              ? true\n              : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\n\nconst isNodeMatchingSelectorFocusable = function (options, node) {\n  if (\n    node.disabled ||\n    isHiddenInput(node) ||\n    isHidden(node, options) ||\n    // For a details element with a summary, the summary element gets the focus\n    isDetailsWithSummary(node) ||\n    isDisabledFromFieldset(node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isNodeMatchingSelectorTabbable = function (options, node) {\n  if (\n    isNonTabbableRadio(node) ||\n    getTabIndex(node) < 0 ||\n    !isNodeMatchingSelectorFocusable(options, node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isShadowRootTabbable = function (shadowHostNode) {\n  const tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nconst sortByOrder = function (candidates) {\n  const regularTabbables = [];\n  const orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    const isScope = !!item.scopeParent;\n    const element = isScope ? item.scopeParent : item;\n    const candidateTabindex = getSortOrderTabIndex(element, isScope);\n    const elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope\n        ? regularTabbables.push(...elements)\n        : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements,\n      });\n    }\n  });\n\n  return orderedTabbables\n    .sort(sortOrderedTabbables)\n    .reduce((acc, sortable) => {\n      sortable.isScope\n        ? acc.push(...sortable.content)\n        : acc.push(sortable.content);\n      return acc;\n    }, [])\n    .concat(regularTabbables);\n};\n\nconst tabbable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorTabbable.bind(null, options),\n        flatten: false,\n        getShadowRoot: options.getShadowRoot,\n        shadowRootFilter: isShadowRootTabbable,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorTabbable.bind(null, options)\n    );\n  }\n  return sortByOrder(candidates);\n};\n\nconst focusable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorFocusable.bind(null, options),\n        flatten: true,\n        getShadowRoot: options.getShadowRoot,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorFocusable.bind(null, options)\n    );\n  }\n\n  return candidates;\n};\n\nconst isTabbable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\n\nconst focusableCandidateSelector = /* #__PURE__ */ candidateSelectors\n  .concat('iframe:not([inert]):not([inert] *)')\n  .join(',');\n\nconst isFocusable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { tabbable, focusable, isTabbable, isFocusable, getTabIndex };\n"],"names":["candidateSelectors","candidateSelector","join","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","element","_element$getRootNode","call","ownerDocument","isInert","node","lookUp","_node$getAttribute","inertAtt","getAttribute","inert","result","closest","parentNode","isContentEditable","_node$getAttribute2","attValue","getCandidates","el","includeContainer","filter","candidates","Array","slice","apply","querySelectorAll","unshift","getCandidatesIteratively","elements","options","elementsToCheck","from","length","shift","tagName","assigned","assignedElements","content","children","nestedCandidates","flatten","push","scopeParent","validCandidate","includes","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","hasTabIndex","isNaN","parseInt","getTabIndex","Error","tabIndex","test","getSortOrderTabIndex","isScope","sortOrderedTabbables","a","b","documentOrder","isInput","isHiddenInput","type","isDetailsWithSummary","r","some","child","getCheckedRadio","nodes","form","i","checked","isTabbableRadio","name","radioScope","queryRadios","radioSet","window","CSS","escape","err","console","error","message","isRadio","isNonTabbableRadio","isNodeAttached","_nodeRoot","nodeRoot","nodeRootHost","host","attached","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","contains","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isZeroArea","_node$getBoundingClie","getBoundingClientRect","width","height","isHidden","_ref","displayCheck","visible","checkVisibility","checkOpacity","opacityProperty","contentVisibilityAuto","visibilityProperty","checkVisibilityCSS","getComputedStyle","visibility","isDirectSummary","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","getClientRects","isDisabledFromFieldset","disabled","item","isNodeMatchingSelectorFocusable","isNodeMatchingSelectorTabbable","isShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","forEach","candidateTabindex","sort","reduce","acc","sortable","concat","tabbable","container","bind","focusable","isTabbable","focusableCandidateSelector","isFocusable"],"mappings":"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"}