{"version":3,"file":"js/826.chunk.js","mappings":"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","sources":["webpack:///./node_modules/tabbable/src/index.js"],"sourcesContent":["// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nconst candidateSelectors = [\n  'input:not([inert])',\n  'select:not([inert])',\n  'textarea:not([inert])',\n  'a[href]:not([inert])',\n  'button:not([inert])',\n  '[tabindex]:not(slot):not([inert])',\n  'audio[controls]:not([inert])',\n  'video[controls]:not([inert])',\n  '[contenteditable]:not([contenteditable=\"false\"]):not([inert])',\n  'details>summary:first-of-type:not([inert])',\n  'details: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 {Element} [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  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  const result = inert || (lookUp && node && isInert(node.parentNode)); // recursive\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, 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\nconst getTabindex = function (node, isScope) {\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    //\n    // isScope is positive for custom element with shadow root or slot that by default\n    // have tabIndex -1, but need to be sorted by document order in order for their\n    // content to be inserted in the correct position\n    if (\n      (isScope ||\n        /^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) ||\n        isContentEditable(node)) &&\n      isNaN(parseInt(node.getAttribute('tabindex'), 10))\n    ) {\n      return 0;\n    }\n  }\n\n  return node.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  // 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    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    // we must do an inert look up to filter out any elements inside an inert ancestor\n    //  because we're limited in the type of selectors we can use in JSDom (see related\n    //  note related to `candidateSelectors`)\n    isInert(node) ||\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 isValidShadowRootTabbable = 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 = getTabindex(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 (el, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([el], options.includeContainer, {\n      filter: isNodeMatchingSelectorTabbable.bind(null, options),\n      flatten: false,\n      getShadowRoot: options.getShadowRoot,\n      shadowRootFilter: isValidShadowRootTabbable,\n    });\n  } else {\n    candidates = getCandidates(\n      el,\n      options.includeContainer,\n      isNodeMatchingSelectorTabbable.bind(null, options)\n    );\n  }\n  return sortByOrder(candidates);\n};\n\nconst focusable = function (el, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([el], options.includeContainer, {\n      filter: isNodeMatchingSelectorFocusable.bind(null, options),\n      flatten: true,\n      getShadowRoot: options.getShadowRoot,\n    });\n  } else {\n    candidates = getCandidates(\n      el,\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')\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 };\n"],"names":["candidateSelectors","candidateSelector","join","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","element","ownerDocument","isInert","node","lookUp","inertAtt","getAttribute","parentNode","getCandidates","el","includeContainer","filter","candidates","Array","slice","apply","querySelectorAll","call","unshift","getCandidatesIteratively","elements","options","elementsToCheck","from","length","shift","tagName","assigned","assignedElements","nestedCandidates","children","flatten","push","scopeParent","includes","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","getTabindex","isScope","tabIndex","test","attValue","isContentEditable","isNaN","parseInt","sortOrderedTabbables","a","b","documentOrder","isInput","isNonTabbableRadio","type","isRadio","name","radioSet","radioScope","form","queryRadios","window","CSS","escape","err","console","error","message","checked","nodes","i","getCheckedRadio","isTabbableRadio","isZeroArea","getBoundingClientRect","width","height","isHidden","displayCheck","getComputedStyle","visibility","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","nodeRoot","nodeRootHost","attached","contains","isNodeAttached","getClientRects","isNodeMatchingSelectorFocusable","disabled","isHiddenInput","some","child","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","forEach","candidateTabindex","content","sort","reduce","acc","sortable","concat","tabbable","bind","focusable","isTabbable","Error","focusableCandidateSelector","isFocusable"],"sourceRoot":""}