{"version":3,"file":"static/js/6631_723b193e72e2d91b6009.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/tabster@6.0.0/node_modules/tabster/dist/tabster.esm.js"],"sourcesContent":["import { nativeFocus, KEYBORG_FOCUSIN, KEYBORG_FOCUSOUT, createKeyborg, disposeKeyborg } from 'keyborg';\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst TabsterAttributeName = \"data-tabster\";\nconst TabsterDummyInputAttributeName = \"data-tabster-dummy\";\nconst DeloserEventName = \"tabster:deloser\";\nconst ModalizerActiveEventName = \"tabster:modalizer:active\";\nconst ModalizerInactiveEventName = \"tabster:modalizer:inactive\";\nconst ModalizerFocusInEventName = \"tabster:modalizer:focusin\";\nconst ModalizerFocusOutEventName = \"tabster:modalizer:focusout\";\nconst ModalizerBeforeFocusOutEventName = \"tabster:modalizer:beforefocusout\";\nconst MoverEventName = \"tabster:mover\";\nconst FocusInEventName = \"tabster:focusin\";\nconst FocusOutEventName = \"tabster:focusout\"; // Event to be triggered when Tabster wants to move focus as the result of\n// keyboard event. This allows to preventDefault() if you want to have\n// some custom logic.\n\nconst MoveFocusEventName = \"tabster:movefocus\"; // Event that can be triggered by the application to programmatically move\n// focus inside Mover.\n\nconst MoverMoveFocusEventName = \"tabster:mover:movefocus\"; // Event that can be triggered by the application to programmatically enter\n// or escape Groupper.\n\nconst GroupperMoveFocusEventName = \"tabster:groupper:movefocus\";\nconst FocusableSelector = /*#__PURE__*/[\"a[href]\", \"button:not([disabled])\", \"input:not([disabled])\", \"select:not([disabled])\", \"textarea:not([disabled])\", \"*[tabindex]\", \"*[contenteditable]\"].join(\", \");\nconst GroupperMoveFocusActions = {\n  Enter: 1,\n  Escape: 2\n};\nconst ObservedElementAccesibilities = {\n  Any: 0,\n  Accessible: 1,\n  Focusable: 2\n};\nconst RestoreFocusOrders = {\n  History: 0,\n  DeloserDefault: 1,\n  RootDefault: 2,\n  DeloserFirst: 3,\n  RootFirst: 4\n};\nconst Visibilities = {\n  Invisible: 0,\n  PartiallyVisible: 1,\n  Visible: 2\n};\nconst RestorerTypes = {\n  Source: 0,\n  Target: 1\n};\nconst MoverDirections = {\n  Both: 0,\n  Vertical: 1,\n  Horizontal: 2,\n  Grid: 3,\n  GridLinear: 4\n};\nconst MoverKeys = {\n  ArrowUp: 1,\n  ArrowDown: 2,\n  ArrowLeft: 3,\n  ArrowRight: 4,\n  PageUp: 5,\n  PageDown: 6,\n  Home: 7,\n  End: 8\n};\nconst GroupperTabbabilities = {\n  Unlimited: 0,\n  Limited: 1,\n  LimitedTrapFocus: 2\n};\nconst SysDummyInputsPositions = {\n  Auto: 0,\n  Inside: 1,\n  Outside: 2\n};\n\nvar Types = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    TabsterAttributeName: TabsterAttributeName,\n    TabsterDummyInputAttributeName: TabsterDummyInputAttributeName,\n    DeloserEventName: DeloserEventName,\n    ModalizerActiveEventName: ModalizerActiveEventName,\n    ModalizerInactiveEventName: ModalizerInactiveEventName,\n    ModalizerFocusInEventName: ModalizerFocusInEventName,\n    ModalizerFocusOutEventName: ModalizerFocusOutEventName,\n    ModalizerBeforeFocusOutEventName: ModalizerBeforeFocusOutEventName,\n    MoverEventName: MoverEventName,\n    FocusInEventName: FocusInEventName,\n    FocusOutEventName: FocusOutEventName,\n    MoveFocusEventName: MoveFocusEventName,\n    MoverMoveFocusEventName: MoverMoveFocusEventName,\n    GroupperMoveFocusEventName: GroupperMoveFocusEventName,\n    FocusableSelector: FocusableSelector,\n    GroupperMoveFocusActions: GroupperMoveFocusActions,\n    ObservedElementAccesibilities: ObservedElementAccesibilities,\n    RestoreFocusOrders: RestoreFocusOrders,\n    Visibilities: Visibilities,\n    RestorerTypes: RestorerTypes,\n    MoverDirections: MoverDirections,\n    MoverKeys: MoverKeys,\n    GroupperTabbabilities: GroupperTabbabilities,\n    SysDummyInputsPositions: SysDummyInputsPositions\n});\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction getTabsterOnElement(tabster, element) {\n  var _a;\n\n  return (_a = tabster.storageEntry(element)) === null || _a === void 0 ? void 0 : _a.tabster;\n}\nfunction updateTabsterByAttribute(tabster, element, dispose) {\n  var _a, _b;\n\n  const newAttrValue = dispose || tabster._noop ? undefined : element.getAttribute(TabsterAttributeName);\n  let entry = tabster.storageEntry(element);\n  let newAttr;\n\n  if (newAttrValue) {\n    if (newAttrValue !== ((_a = entry === null || entry === void 0 ? void 0 : entry.attr) === null || _a === void 0 ? void 0 : _a.string)) {\n      try {\n        const newValue = JSON.parse(newAttrValue);\n\n        if (typeof newValue !== \"object\") {\n          throw new Error(`Value is not a JSON object, got '${newAttrValue}'.`);\n        }\n\n        newAttr = {\n          string: newAttrValue,\n          object: newValue\n        };\n      } catch (e) {\n        if (process.env.NODE_ENV === 'development') {\n          console.error(`data-tabster attribute error: ${e}`, element);\n        }\n      }\n    } else {\n      return;\n    }\n  } else if (!entry) {\n    return;\n  }\n\n  if (!entry) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    entry = tabster.storageEntry(element, true);\n  }\n\n  if (!entry.tabster) {\n    entry.tabster = {};\n  }\n\n  const tabsterOnElement = entry.tabster || {};\n  const oldTabsterProps = ((_b = entry.attr) === null || _b === void 0 ? void 0 : _b.object) || {};\n  const newTabsterProps = (newAttr === null || newAttr === void 0 ? void 0 : newAttr.object) || {};\n\n  for (const key of Object.keys(oldTabsterProps)) {\n    if (!newTabsterProps[key]) {\n      if (key === \"root\") {\n        const root = tabsterOnElement[key];\n\n        if (root) {\n          tabster.root.onRoot(root, true);\n        }\n      }\n\n      switch (key) {\n        case \"deloser\":\n        case \"root\":\n        case \"groupper\":\n        case \"modalizer\":\n        case \"restorer\":\n        case \"mover\":\n          // eslint-disable-next-line no-case-declarations\n          const part = tabsterOnElement[key];\n\n          if (part) {\n            part.dispose();\n            delete tabsterOnElement[key];\n          }\n\n          break;\n\n        case \"observed\":\n          delete tabsterOnElement[key];\n\n          if (tabster.observedElement) {\n            tabster.observedElement.onObservedElementUpdate(element);\n          }\n\n          break;\n\n        case \"focusable\":\n        case \"outline\":\n        case \"uncontrolled\":\n        case \"sys\":\n          delete tabsterOnElement[key];\n          break;\n      }\n    }\n  }\n\n  for (const key of Object.keys(newTabsterProps)) {\n    const sys = newTabsterProps.sys;\n\n    switch (key) {\n      case \"deloser\":\n        if (tabsterOnElement.deloser) {\n          tabsterOnElement.deloser.setProps(newTabsterProps.deloser);\n        } else {\n          if (tabster.deloser) {\n            tabsterOnElement.deloser = tabster.deloser.createDeloser(element, newTabsterProps.deloser);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Deloser API used before initialization, please call `getDeloser()`\");\n          }\n        }\n\n        break;\n\n      case \"root\":\n        if (tabsterOnElement.root) {\n          tabsterOnElement.root.setProps(newTabsterProps.root);\n        } else {\n          tabsterOnElement.root = tabster.root.createRoot(element, newTabsterProps.root, sys);\n        }\n\n        tabster.root.onRoot(tabsterOnElement.root);\n        break;\n\n      case \"modalizer\":\n        if (tabsterOnElement.modalizer) {\n          tabsterOnElement.modalizer.setProps(newTabsterProps.modalizer);\n        } else {\n          if (tabster.modalizer) {\n            tabsterOnElement.modalizer = tabster.modalizer.createModalizer(element, newTabsterProps.modalizer, sys);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Modalizer API used before initialization, please call `getModalizer()`\");\n          }\n        }\n\n        break;\n\n      case \"restorer\":\n        if (tabsterOnElement.restorer) {\n          tabsterOnElement.restorer.setProps(newTabsterProps.restorer);\n        } else {\n          if (tabster.restorer) {\n            if (newTabsterProps.restorer) {\n              tabsterOnElement.restorer = tabster.restorer.createRestorer(element, newTabsterProps.restorer);\n            }\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Restorer API used before initialization, please call `getRestorer()`\");\n          }\n        }\n\n        break;\n\n      case \"focusable\":\n        tabsterOnElement.focusable = newTabsterProps.focusable;\n        break;\n\n      case \"groupper\":\n        if (tabsterOnElement.groupper) {\n          tabsterOnElement.groupper.setProps(newTabsterProps.groupper);\n        } else {\n          if (tabster.groupper) {\n            tabsterOnElement.groupper = tabster.groupper.createGroupper(element, newTabsterProps.groupper, sys);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Groupper API used before initialization, please call `getGroupper()`\");\n          }\n        }\n\n        break;\n\n      case \"mover\":\n        if (tabsterOnElement.mover) {\n          tabsterOnElement.mover.setProps(newTabsterProps.mover);\n        } else {\n          if (tabster.mover) {\n            tabsterOnElement.mover = tabster.mover.createMover(element, newTabsterProps.mover, sys);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Mover API used before initialization, please call `getMover()`\");\n          }\n        }\n\n        break;\n\n      case \"observed\":\n        if (tabster.observedElement) {\n          tabsterOnElement.observed = newTabsterProps.observed;\n          tabster.observedElement.onObservedElementUpdate(element);\n        } else if (process.env.NODE_ENV === 'development') {\n          console.error(\"ObservedElement API used before initialization, please call `getObservedElement()`\");\n        }\n\n        break;\n\n      case \"uncontrolled\":\n        tabsterOnElement.uncontrolled = newTabsterProps.uncontrolled;\n        break;\n\n      case \"outline\":\n        if (tabster.outline) {\n          tabsterOnElement.outline = newTabsterProps.outline;\n        } else if (process.env.NODE_ENV === 'development') {\n          console.error(\"Outline API used before initialization, please call `getOutline()`\");\n        }\n\n        break;\n\n      case \"sys\":\n        tabsterOnElement.sys = newTabsterProps.sys;\n        break;\n\n      default:\n        console.error(`Unknown key '${key}' in data-tabster attribute value.`);\n    }\n  }\n\n  if (newAttr) {\n    entry.attr = newAttr;\n  } else {\n    if (Object.keys(tabsterOnElement).length === 0) {\n      delete entry.tabster;\n      delete entry.attr;\n    }\n\n    tabster.storageEntry(element, false);\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction createEventTarget(getWindow) {\n  const global = getWindow();\n\n  try {\n    if (global.EventTarget) {\n      return new global.EventTarget();\n    }\n  } catch (error) {\n    // thrown if EventTarget is not constructable or doesn't exit\n    if (!(error instanceof TypeError)) {\n      throw error;\n    }\n  }\n\n  return global.document.createElement(\"div\");\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _createMutationObserver = callback => new MutationObserver(callback);\n\nconst _createTreeWalker = (doc, root, whatToShow, filter) => doc.createTreeWalker(root, whatToShow, filter);\n\nconst _getParentNode = node => node ? node.parentNode : null;\n\nconst _getParentElement = element => element ? element.parentElement : null;\n\nconst _nodeContains = (parent, child) => !!(child && (parent === null || parent === void 0 ? void 0 : parent.contains(child)));\n\nconst _getActiveElement = doc => doc.activeElement;\n\nconst _querySelector = (element, selector) => element.querySelector(selector);\n\nconst _querySelectorAll = (element, selector) => Array.prototype.slice.call(element.querySelectorAll(selector), 0);\n\nconst _getElementById = (doc, id) => doc.getElementById(id);\n\nconst _getFirstChild = node => (node === null || node === void 0 ? void 0 : node.firstChild) || null;\n\nconst _getLastChild = node => (node === null || node === void 0 ? void 0 : node.lastChild) || null;\n\nconst _getNextSibling = node => (node === null || node === void 0 ? void 0 : node.nextSibling) || null;\n\nconst _getPreviousSibling = node => (node === null || node === void 0 ? void 0 : node.previousSibling) || null;\n\nconst _getFirstElementChild = element => (element === null || element === void 0 ? void 0 : element.firstElementChild) || null;\n\nconst _getLastElementChild = element => (element === null || element === void 0 ? void 0 : element.lastElementChild) || null;\n\nconst _getNextElementSibling = element => (element === null || element === void 0 ? void 0 : element.nextElementSibling) || null;\n\nconst _getPreviousElementSibling = element => (element === null || element === void 0 ? void 0 : element.previousElementSibling) || null;\n\nconst _appendChild = (parent, child) => parent.appendChild(child);\n\nconst _insertBefore = (parent, child, referenceChild) => parent.insertBefore(child, referenceChild);\n\nconst _getSelection = ref => {\n  var _a;\n\n  return ((_a = ref.ownerDocument) === null || _a === void 0 ? void 0 : _a.getSelection()) || null;\n};\n\nconst dom = {\n  createMutationObserver: _createMutationObserver,\n  createTreeWalker: _createTreeWalker,\n  getParentNode: _getParentNode,\n  getParentElement: _getParentElement,\n  nodeContains: _nodeContains,\n  getActiveElement: _getActiveElement,\n  querySelector: _querySelector,\n  querySelectorAll: _querySelectorAll,\n  getElementById: _getElementById,\n  getFirstChild: _getFirstChild,\n  getLastChild: _getLastChild,\n  getNextSibling: _getNextSibling,\n  getPreviousSibling: _getPreviousSibling,\n  getFirstElementChild: _getFirstElementChild,\n  getLastElementChild: _getLastElementChild,\n  getNextElementSibling: _getNextElementSibling,\n  getPreviousElementSibling: _getPreviousElementSibling,\n  appendChild: _appendChild,\n  insertBefore: _insertBefore,\n  getSelection: _getSelection\n};\nfunction setDOMAPI(domapi) {\n  for (const key of Object.keys(domapi)) {\n    dom[key] = domapi[key];\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nlet _isBrokenIE11;\n\nconst _DOMRect = typeof DOMRect !== \"undefined\" ? DOMRect : class {\n  constructor(x, y, width, height) {\n    this.left = x || 0;\n    this.top = y || 0;\n    this.right = (x || 0) + (width || 0);\n    this.bottom = (y || 0) + (height || 0);\n  }\n\n};\n\nlet _uidCounter = 0;\n\ntry {\n  // IE11 only accepts `filter` argument as a function (not object with the `acceptNode`\n  // property as the docs define). Also `entityReferenceExpansion` argument is not\n  // optional. And it throws exception when the above arguments aren't there.\n  document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT);\n  _isBrokenIE11 = false;\n} catch (e) {\n  _isBrokenIE11 = true;\n}\n\nconst _updateDummyInputsTimeout = 100;\nfunction getInstanceContext(getWindow) {\n  const win = getWindow();\n  let ctx = win.__tabsterInstanceContext;\n\n  if (!ctx) {\n    ctx = {\n      elementByUId: {},\n      basics: {\n        Promise: win.Promise || undefined,\n        WeakRef: win.WeakRef || undefined\n      },\n      containerBoundingRectCache: {},\n      lastContainerBoundingRectCacheId: 0,\n      fakeWeakRefs: [],\n      fakeWeakRefsStarted: false\n    };\n    win.__tabsterInstanceContext = ctx;\n  }\n\n  return ctx;\n}\nfunction disposeInstanceContext(win) {\n  const ctx = win.__tabsterInstanceContext;\n\n  if (ctx) {\n    ctx.elementByUId = {};\n    delete ctx.WeakRef;\n    ctx.containerBoundingRectCache = {};\n\n    if (ctx.containerBoundingRectCacheTimer) {\n      win.clearTimeout(ctx.containerBoundingRectCacheTimer);\n    }\n\n    if (ctx.fakeWeakRefsTimer) {\n      win.clearTimeout(ctx.fakeWeakRefsTimer);\n    }\n\n    ctx.fakeWeakRefs = [];\n    delete win.__tabsterInstanceContext;\n  }\n}\nfunction createWeakMap(win) {\n  const ctx = win.__tabsterInstanceContext;\n  return new ((ctx === null || ctx === void 0 ? void 0 : ctx.basics.WeakMap) || WeakMap)();\n}\nfunction hasSubFocusable(element) {\n  return !!element.querySelector(FocusableSelector);\n}\n\nclass FakeWeakRef {\n  constructor(target) {\n    this._target = target;\n  }\n\n  deref() {\n    return this._target;\n  }\n\n  static cleanup(fwr, forceRemove) {\n    if (!fwr._target) {\n      return true;\n    }\n\n    if (forceRemove || !documentContains(fwr._target.ownerDocument, fwr._target)) {\n      delete fwr._target;\n      return true;\n    }\n\n    return false;\n  }\n\n}\n\nclass WeakHTMLElement {\n  constructor(getWindow, element, data) {\n    const context = getInstanceContext(getWindow);\n    let ref;\n\n    if (context.WeakRef) {\n      ref = new context.WeakRef(element);\n    } else {\n      ref = new FakeWeakRef(element);\n      context.fakeWeakRefs.push(ref);\n    }\n\n    this._ref = ref;\n    this._data = data;\n  }\n\n  get() {\n    const ref = this._ref;\n    let element;\n\n    if (ref) {\n      element = ref.deref();\n\n      if (!element) {\n        delete this._ref;\n      }\n    }\n\n    return element;\n  }\n\n  getData() {\n    return this._data;\n  }\n\n}\nfunction cleanupFakeWeakRefs(getWindow, forceRemove) {\n  const context = getInstanceContext(getWindow);\n  context.fakeWeakRefs = context.fakeWeakRefs.filter(e => !FakeWeakRef.cleanup(e, forceRemove));\n}\nfunction startFakeWeakRefsCleanup(getWindow) {\n  const context = getInstanceContext(getWindow);\n\n  if (!context.fakeWeakRefsStarted) {\n    context.fakeWeakRefsStarted = true;\n    context.WeakRef = getWeakRef(context);\n  }\n\n  if (!context.fakeWeakRefsTimer) {\n    context.fakeWeakRefsTimer = getWindow().setTimeout(() => {\n      context.fakeWeakRefsTimer = undefined;\n      cleanupFakeWeakRefs(getWindow);\n      startFakeWeakRefsCleanup(getWindow);\n    }, 2 * 60 * 1000); // 2 minutes.\n  }\n}\nfunction stopFakeWeakRefsCleanupAndClearStorage(getWindow) {\n  const context = getInstanceContext(getWindow);\n  context.fakeWeakRefsStarted = false;\n\n  if (context.fakeWeakRefsTimer) {\n    getWindow().clearTimeout(context.fakeWeakRefsTimer);\n    context.fakeWeakRefsTimer = undefined;\n    context.fakeWeakRefs = [];\n  }\n}\nfunction createElementTreeWalker(doc, root, acceptNode) {\n  // IE11 will throw an exception when the TreeWalker root is not an Element.\n  if (root.nodeType !== Node.ELEMENT_NODE) {\n    return undefined;\n  } // TypeScript isn't aware of IE11 behaving badly.\n\n\n  const filter = _isBrokenIE11 ? acceptNode : {\n    acceptNode\n  };\n  return dom.createTreeWalker(doc, root, NodeFilter.SHOW_ELEMENT, filter, // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore: We still don't want to completely break IE11, so, entityReferenceExpansion argument is not optional.\n  false\n  /* Last argument is not optional for IE11! */\n  );\n}\nfunction getBoundingRect(getWindow, element) {\n  let cacheId = element.__tabsterCacheId;\n  const context = getInstanceContext(getWindow);\n  const cached = cacheId ? context.containerBoundingRectCache[cacheId] : undefined;\n\n  if (cached) {\n    return cached.rect;\n  }\n\n  const scrollingElement = element.ownerDocument && element.ownerDocument.documentElement;\n\n  if (!scrollingElement) {\n    return new _DOMRect();\n  } // A bounding rect of the top-level element contains the whole page regardless of the\n  // scrollbar. So, we improvise a little and limiting the final result...\n\n\n  let left = 0;\n  let top = 0;\n  let right = scrollingElement.clientWidth;\n  let bottom = scrollingElement.clientHeight;\n\n  if (element !== scrollingElement) {\n    const r = element.getBoundingClientRect();\n    left = Math.max(left, r.left);\n    top = Math.max(top, r.top);\n    right = Math.min(right, r.right);\n    bottom = Math.min(bottom, r.bottom);\n  }\n\n  const rect = new _DOMRect(left < right ? left : -1, top < bottom ? top : -1, left < right ? right - left : 0, top < bottom ? bottom - top : 0);\n\n  if (!cacheId) {\n    cacheId = \"r-\" + ++context.lastContainerBoundingRectCacheId;\n    element.__tabsterCacheId = cacheId;\n  }\n\n  context.containerBoundingRectCache[cacheId] = {\n    rect,\n    element\n  };\n\n  if (!context.containerBoundingRectCacheTimer) {\n    context.containerBoundingRectCacheTimer = window.setTimeout(() => {\n      context.containerBoundingRectCacheTimer = undefined;\n\n      for (const cId of Object.keys(context.containerBoundingRectCache)) {\n        delete context.containerBoundingRectCache[cId].element.__tabsterCacheId;\n      }\n\n      context.containerBoundingRectCache = {};\n    }, 50);\n  }\n\n  return rect;\n}\nfunction isElementVerticallyVisibleInContainer(getWindow, element, tolerance) {\n  const container = getScrollableContainer(element);\n\n  if (!container) {\n    return false;\n  }\n\n  const containerRect = getBoundingRect(getWindow, container);\n  const elementRect = element.getBoundingClientRect();\n  const intersectionTolerance = elementRect.height * (1 - tolerance);\n  const topIntersection = Math.max(0, containerRect.top - elementRect.top);\n  const bottomIntersection = Math.max(0, elementRect.bottom - containerRect.bottom);\n  const totalIntersection = topIntersection + bottomIntersection;\n  return totalIntersection === 0 || totalIntersection <= intersectionTolerance;\n}\nfunction scrollIntoView(getWindow, element, alignToTop) {\n  // Built-in DOM's scrollIntoView() is cool, but when we have nested containers,\n  // it scrolls all of them, not just the deepest one. So, trying to work it around.\n  const container = getScrollableContainer(element);\n\n  if (container) {\n    const containerRect = getBoundingRect(getWindow, container);\n    const elementRect = element.getBoundingClientRect();\n\n    if (alignToTop) {\n      container.scrollTop += elementRect.top - containerRect.top;\n    } else {\n      container.scrollTop += elementRect.bottom - containerRect.bottom;\n    }\n  }\n}\nfunction getScrollableContainer(element) {\n  const doc = element.ownerDocument;\n\n  if (doc) {\n    for (let el = dom.getParentElement(element); el; el = dom.getParentElement(el)) {\n      if (el.scrollWidth > el.clientWidth || el.scrollHeight > el.clientHeight) {\n        return el;\n      }\n    }\n\n    return doc.documentElement;\n  }\n\n  return null;\n}\nfunction makeFocusIgnored(element) {\n  element.__shouldIgnoreFocus = true;\n}\nfunction shouldIgnoreFocus(element) {\n  return !!element.__shouldIgnoreFocus;\n}\nfunction getUId(wnd) {\n  const rnd = new Uint32Array(4);\n\n  if (wnd.crypto && wnd.crypto.getRandomValues) {\n    wnd.crypto.getRandomValues(rnd);\n  } else if (wnd.msCrypto && wnd.msCrypto.getRandomValues) {\n    wnd.msCrypto.getRandomValues(rnd);\n  } else {\n    for (let i = 0; i < rnd.length; i++) {\n      rnd[i] = 0xffffffff * Math.random();\n    }\n  }\n\n  const srnd = [];\n\n  for (let i = 0; i < rnd.length; i++) {\n    srnd.push(rnd[i].toString(36));\n  }\n\n  srnd.push(\"|\");\n  srnd.push((++_uidCounter).toString(36));\n  srnd.push(\"|\");\n  srnd.push(Date.now().toString(36));\n  return srnd.join(\"\");\n}\nfunction getElementUId(getWindow, element) {\n  const context = getInstanceContext(getWindow);\n  let uid = element.__tabsterElementUID;\n\n  if (!uid) {\n    uid = element.__tabsterElementUID = getUId(getWindow());\n  }\n\n  if (!context.elementByUId[uid] && documentContains(element.ownerDocument, element)) {\n    context.elementByUId[uid] = new WeakHTMLElement(getWindow, element);\n  }\n\n  return uid;\n}\nfunction getWindowUId(win) {\n  let uid = win.__tabsterCrossOriginWindowUID;\n\n  if (!uid) {\n    uid = win.__tabsterCrossOriginWindowUID = getUId(win);\n  }\n\n  return uid;\n}\nfunction clearElementCache(getWindow, parent) {\n  const context = getInstanceContext(getWindow);\n\n  for (const key of Object.keys(context.elementByUId)) {\n    const wel = context.elementByUId[key];\n    const el = wel && wel.get();\n\n    if (el && parent) {\n      if (!dom.nodeContains(parent, el)) {\n        continue;\n      }\n    }\n\n    delete context.elementByUId[key];\n  }\n} // IE11 doesn't have document.contains()...\n\nfunction documentContains(doc, element) {\n  return dom.nodeContains(doc === null || doc === void 0 ? void 0 : doc.body, element);\n}\nfunction matchesSelector(element, selector) {\n  const matches = element.matches || element.matchesSelector || element.msMatchesSelector || element.webkitMatchesSelector;\n  return matches && matches.call(element, selector);\n}\nfunction getPromise(getWindow) {\n  const context = getInstanceContext(getWindow);\n\n  if (context.basics.Promise) {\n    return context.basics.Promise;\n  }\n\n  throw new Error(\"No Promise defined.\");\n}\nfunction getWeakRef(context) {\n  return context.basics.WeakRef;\n}\nlet _lastTabsterPartId = 0;\nclass TabsterPart {\n  constructor(tabster, element, props) {\n    const getWindow = tabster.getWindow;\n    this._tabster = tabster;\n    this._element = new WeakHTMLElement(getWindow, element);\n    this._props = { ...props\n    };\n    this.id = \"i\" + ++_lastTabsterPartId;\n  }\n\n  getElement() {\n    return this._element.get();\n  }\n\n  getProps() {\n    return this._props;\n  }\n\n  setProps(props) {\n    this._props = { ...props\n    };\n  }\n\n}\n/**\r\n * Dummy HTML elements that are used as focus sentinels for the DOM enclosed within them\r\n */\n\nclass DummyInput {\n  constructor(getWindow, isOutside, props, element, fixedTarget) {\n    var _a;\n\n    this._focusIn = e => {\n      if (this._fixedTarget) {\n        const target = this._fixedTarget.get();\n\n        if (target) {\n          nativeFocus(target);\n        }\n\n        return;\n      }\n\n      const input = this.input;\n\n      if (this.onFocusIn && input) {\n        const relatedTarget = e.relatedTarget;\n        this.onFocusIn(this, this._isBackward(true, input, relatedTarget), relatedTarget);\n      }\n    };\n\n    this._focusOut = e => {\n      if (this._fixedTarget) {\n        return;\n      }\n\n      this.useDefaultAction = false;\n      const input = this.input;\n\n      if (this.onFocusOut && input) {\n        const relatedTarget = e.relatedTarget;\n        this.onFocusOut(this, this._isBackward(false, input, relatedTarget), relatedTarget);\n      }\n    };\n\n    const win = getWindow();\n    const input = win.document.createElement(\"i\");\n    input.tabIndex = 0;\n    input.setAttribute(\"role\", \"none\");\n    input.setAttribute(TabsterDummyInputAttributeName, \"\");\n    input.setAttribute(\"aria-hidden\", \"true\");\n    const style = input.style;\n    style.position = \"fixed\";\n    style.width = style.height = \"1px\";\n    style.opacity = \"0.001\";\n    style.zIndex = \"-1\";\n    style.setProperty(\"content-visibility\", \"hidden\");\n    makeFocusIgnored(input);\n    this.input = input;\n    this.isFirst = props.isFirst;\n    this.isOutside = isOutside;\n    this._isPhantom = (_a = props.isPhantom) !== null && _a !== void 0 ? _a : false;\n    this._fixedTarget = fixedTarget;\n    input.addEventListener(\"focusin\", this._focusIn);\n    input.addEventListener(\"focusout\", this._focusOut);\n    input.__tabsterDummyContainer = element;\n\n    if (this._isPhantom) {\n      this._disposeTimer = win.setTimeout(() => {\n        delete this._disposeTimer;\n        this.dispose();\n      }, 0);\n\n      this._clearDisposeTimeout = () => {\n        if (this._disposeTimer) {\n          win.clearTimeout(this._disposeTimer);\n          delete this._disposeTimer;\n        }\n\n        delete this._clearDisposeTimeout;\n      };\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    if (this._clearDisposeTimeout) {\n      this._clearDisposeTimeout();\n    }\n\n    const input = this.input;\n\n    if (!input) {\n      return;\n    }\n\n    delete this._fixedTarget;\n    delete this.onFocusIn;\n    delete this.onFocusOut;\n    delete this.input;\n    input.removeEventListener(\"focusin\", this._focusIn);\n    input.removeEventListener(\"focusout\", this._focusOut);\n    delete input.__tabsterDummyContainer;\n    (_a = dom.getParentNode(input)) === null || _a === void 0 ? void 0 : _a.removeChild(input);\n  }\n\n  setTopLeft(top, left) {\n    var _a;\n\n    const style = (_a = this.input) === null || _a === void 0 ? void 0 : _a.style;\n\n    if (style) {\n      style.top = `${top}px`;\n      style.left = `${left}px`;\n    }\n  }\n\n  _isBackward(isIn, current, previous) {\n    return isIn && !previous ? !this.isFirst : !!(previous && current.compareDocumentPosition(previous) & Node.DOCUMENT_POSITION_FOLLOWING);\n  }\n\n}\nconst DummyInputManagerPriorities = {\n  Root: 1,\n  Modalizer: 2,\n  Mover: 3,\n  Groupper: 4\n};\nclass DummyInputManager {\n  constructor(tabster, element, priority, sys, outsideByDefault, callForDefaultAction) {\n    this._element = element;\n    this._instance = new DummyInputManagerCore(tabster, element, this, priority, sys, outsideByDefault, callForDefaultAction);\n  }\n\n  _setHandlers(onFocusIn, onFocusOut) {\n    this._onFocusIn = onFocusIn;\n    this._onFocusOut = onFocusOut;\n  }\n\n  moveOut(backwards) {\n    var _a;\n\n    (_a = this._instance) === null || _a === void 0 ? void 0 : _a.moveOut(backwards);\n  }\n\n  moveOutWithDefaultAction(backwards, relatedEvent) {\n    var _a;\n\n    (_a = this._instance) === null || _a === void 0 ? void 0 : _a.moveOutWithDefaultAction(backwards, relatedEvent);\n  }\n\n  getHandler(isIn) {\n    return isIn ? this._onFocusIn : this._onFocusOut;\n  }\n\n  setTabbable(tabbable) {\n    var _a;\n\n    (_a = this._instance) === null || _a === void 0 ? void 0 : _a.setTabbable(this, tabbable);\n  }\n\n  dispose() {\n    if (this._instance) {\n      this._instance.dispose(this);\n\n      delete this._instance;\n    }\n\n    delete this._onFocusIn;\n    delete this._onFocusOut;\n  }\n\n  static moveWithPhantomDummy(tabster, element, // The target element to move to or out of.\n  moveOutOfElement, // Whether to move out of the element or into it.\n  isBackward, // Are we tabbing of shift-tabbing?\n  relatedEvent // The event that triggered the move.\n  ) {\n    var _a; // Phantom dummy is a hack to use browser's default action to move\n    // focus from a specific point in the application to the next/previous\n    // element. Default action is needed because next focusable element\n    // is not always available to focus directly (for example, next focusable\n    // is inside isolated iframe) or for uncontrolled areas we want to make\n    // sure that something that controls it takes care of the focusing.\n    // It works in a way that during the Tab key handling, we create a dummy\n    // input element, place it to the specific place in the DOM and focus it,\n    // then the default action of the Tab press will move focus from our dummy\n    // input. And we remove it from the DOM right after that.\n\n\n    const dummy = new DummyInput(tabster.getWindow, true, {\n      isPhantom: true,\n      isFirst: true\n    });\n    const input = dummy.input;\n\n    if (input) {\n      let parent;\n      let insertBefore; // Let's say we have a following DOM structure:\n      // <div>\n      //   <button>Button1</button>\n      //   <div id=\"uncontrolled\" data-tabster={uncontrolled: {}}>\n      //     <button>Button2</button>\n      //     <button>Button3</button>\n      //   </div>\n      //   <button>Button4</button>\n      // </div>\n      //\n      // We pass the \"uncontrolled\" div as the element to move to or out of.\n      //\n      // When we pass moveOutOfElement=true and isBackward=false,\n      // the phantom dummy input will be inserted before Button4.\n      //\n      // When we pass moveOutOfElement=true and isBackward=true, there are\n      // two cases. If the uncontrolled element is focusable (has tabindex=0),\n      // the phantom dummy input will be inserted after Button1. If the\n      // uncontrolled element is not focusable, the phantom dummy input will be\n      // inserted before Button2.\n      //\n      // When we pass moveOutOfElement=false and isBackward=false, the\n      // phantom dummy input will be inserted after Button1.\n      //\n      // When we pass moveOutOfElement=false and isBackward=true, the phantom\n      // dummy input will be inserted before Button4.\n      //\n      // And we have a corner case for <body> and we make sure that the inserted\n      // dummy is inserted properly when there are existing permanent dummies.\n\n      if (element.tagName === \"BODY\") {\n        // We cannot insert elements outside of BODY.\n        parent = element;\n        insertBefore = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? dom.getFirstElementChild(element) : null;\n      } else {\n        if (moveOutOfElement && (!isBackward || isBackward && !tabster.focusable.isFocusable(element, false, true, true))) {\n          parent = element;\n          insertBefore = isBackward ? element.firstElementChild : null;\n        } else {\n          parent = dom.getParentElement(element);\n          insertBefore = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? element : dom.getNextElementSibling(element);\n        }\n\n        let potentialDummy;\n        let dummyFor;\n\n        do {\n          // This is a safety pillow for the cases when someone, combines\n          // groupper with uncontrolled on the same node. Which is technically\n          // not correct, but moving into the container element via its dummy\n          // input would produce a correct behaviour in uncontrolled mode.\n          potentialDummy = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? dom.getPreviousElementSibling(insertBefore) : insertBefore;\n          dummyFor = (_a = potentialDummy === null || potentialDummy === void 0 ? void 0 : potentialDummy.__tabsterDummyContainer) === null || _a === void 0 ? void 0 : _a.get();\n\n          if (dummyFor === element) {\n            insertBefore = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? potentialDummy : dom.getNextElementSibling(potentialDummy);\n          } else {\n            dummyFor = undefined;\n          }\n        } while (dummyFor);\n      }\n\n      if (parent && dispatchMoveFocusEvent({\n        by: \"root\",\n        owner: parent,\n        next: null,\n        relatedEvent\n      })) {\n        dom.insertBefore(parent, input, insertBefore);\n        nativeFocus(input);\n      }\n    }\n  }\n\n  static addPhantomDummyWithTarget(tabster, sourceElement, isBackward, targetElement) {\n    const dummy = new DummyInput(tabster.getWindow, true, {\n      isPhantom: true,\n      isFirst: true\n    }, undefined, new WeakHTMLElement(tabster.getWindow, targetElement));\n    const input = dummy.input;\n\n    if (input) {\n      let dummyParent;\n      let insertBefore;\n\n      if (hasSubFocusable(sourceElement) && !isBackward) {\n        dummyParent = sourceElement;\n        insertBefore = dom.getFirstElementChild(sourceElement);\n      } else {\n        dummyParent = dom.getParentElement(sourceElement);\n        insertBefore = isBackward ? sourceElement : dom.getNextElementSibling(sourceElement);\n      }\n\n      if (dummyParent) {\n        dom.insertBefore(dummyParent, input, insertBefore);\n      }\n    }\n  }\n\n}\n\nfunction setDummyInputDebugValue(dummy, wrappers) {\n  var _a;\n\n  const what = {\n    1: \"Root\",\n    2: \"Modalizer\",\n    3: \"Mover\",\n    4: \"Groupper\"\n  };\n  (_a = dummy.input) === null || _a === void 0 ? void 0 : _a.setAttribute(TabsterDummyInputAttributeName, [`isFirst=${dummy.isFirst}`, `isOutside=${dummy.isOutside}`, ...wrappers.map(w => `(${what[w.priority]}, tabbable=${w.tabbable})`)].join(\", \"));\n}\n\nclass DummyInputObserver {\n  constructor(win) {\n    this._updateQueue = new Set();\n    this._lastUpdateQueueTime = 0;\n    this._changedParents = new WeakSet();\n    this._dummyElements = [];\n    this._dummyCallbacks = new WeakMap();\n\n    this._domChanged = parent => {\n      var _a;\n\n      if (this._changedParents.has(parent)) {\n        return;\n      }\n\n      this._changedParents.add(parent);\n\n      if (this._updateDummyInputsTimer) {\n        return;\n      }\n\n      this._updateDummyInputsTimer = (_a = this._win) === null || _a === void 0 ? void 0 : _a.call(this).setTimeout(() => {\n        delete this._updateDummyInputsTimer;\n\n        for (const ref of this._dummyElements) {\n          const dummyElement = ref.get();\n\n          if (dummyElement) {\n            const callback = this._dummyCallbacks.get(dummyElement);\n\n            if (callback) {\n              const dummyParent = dom.getParentNode(dummyElement);\n\n              if (!dummyParent || this._changedParents.has(dummyParent)) {\n                callback();\n              }\n            }\n          }\n        }\n\n        this._changedParents = new WeakSet();\n      }, _updateDummyInputsTimeout);\n    };\n\n    this._win = win;\n  }\n\n  add(dummy, callback) {\n    if (!this._dummyCallbacks.has(dummy) && this._win) {\n      this._dummyElements.push(new WeakHTMLElement(this._win, dummy));\n\n      this._dummyCallbacks.set(dummy, callback);\n\n      this.domChanged = this._domChanged;\n    }\n  }\n\n  remove(dummy) {\n    this._dummyElements = this._dummyElements.filter(ref => {\n      const element = ref.get();\n      return element && element !== dummy;\n    });\n\n    this._dummyCallbacks.delete(dummy);\n\n    if (this._dummyElements.length === 0) {\n      delete this.domChanged;\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    const win = (_a = this._win) === null || _a === void 0 ? void 0 : _a.call(this);\n\n    if (this._updateTimer) {\n      win === null || win === void 0 ? void 0 : win.clearTimeout(this._updateTimer);\n      delete this._updateTimer;\n    }\n\n    if (this._updateDummyInputsTimer) {\n      win === null || win === void 0 ? void 0 : win.clearTimeout(this._updateDummyInputsTimer);\n      delete this._updateDummyInputsTimer;\n    }\n\n    this._changedParents = new WeakSet();\n    this._dummyCallbacks = new WeakMap();\n    this._dummyElements = [];\n\n    this._updateQueue.clear();\n\n    delete this.domChanged;\n    delete this._win;\n  }\n\n  updatePositions(compute) {\n    if (!this._win) {\n      // As this is a public method, we make sure that it has no effect when\n      // called after dispose().\n      return;\n    }\n\n    this._updateQueue.add(compute);\n\n    this._lastUpdateQueueTime = Date.now();\n\n    this._scheduledUpdatePositions();\n  }\n\n  _scheduledUpdatePositions() {\n    var _a;\n\n    if (this._updateTimer) {\n      return;\n    }\n\n    this._updateTimer = (_a = this._win) === null || _a === void 0 ? void 0 : _a.call(this).setTimeout(() => {\n      delete this._updateTimer; // updatePositions() might be called quite a lot during the scrolling.\n      // So, instead of clearing the timeout and scheduling a new one, we\n      // check if enough time has passed since the last updatePositions() call\n      // and only schedule a new one if not.\n      // At maximum, we will update dummy inputs positions\n      // _updateDummyInputsTimeout * 2 after the last updatePositions() call.\n\n      if (this._lastUpdateQueueTime + _updateDummyInputsTimeout <= Date.now()) {\n        // A cache for current bulk of updates to reduce getComputedStyle() calls.\n        const scrollTopLeftCache = new Map();\n        const setTopLeftCallbacks = [];\n\n        for (const compute of this._updateQueue) {\n          setTopLeftCallbacks.push(compute(scrollTopLeftCache));\n        }\n\n        this._updateQueue.clear(); // We're splitting the computation of offsets and setting them to avoid extra\n        // reflows.\n\n\n        for (const setTopLeft of setTopLeftCallbacks) {\n          setTopLeft();\n        } // Explicitly clear to not hold references till the next garbage collection.\n\n\n        scrollTopLeftCache.clear();\n      } else {\n        this._scheduledUpdatePositions();\n      }\n    }, _updateDummyInputsTimeout);\n  }\n\n}\n/**\r\n * Parent class that encapsulates the behaviour of dummy inputs (focus sentinels)\r\n */\n\nclass DummyInputManagerCore {\n  constructor(tabster, element, manager, priority, sys, outsideByDefault, callForDefaultAction) {\n    this._wrappers = [];\n    this._isOutside = false;\n    this._transformElements = new Set();\n\n    this._onFocusIn = (dummyInput, isBackward, relatedTarget) => {\n      this._onFocus(true, dummyInput, isBackward, relatedTarget);\n    };\n\n    this._onFocusOut = (dummyInput, isBackward, relatedTarget) => {\n      this._onFocus(false, dummyInput, isBackward, relatedTarget);\n    };\n\n    this.moveOut = backwards => {\n      var _a;\n\n      const first = this._firstDummy;\n      const last = this._lastDummy;\n\n      if (first && last) {\n        // For the sake of performance optimization, the dummy input\n        // position in the DOM updates asynchronously from the DOM change.\n        // Calling _ensurePosition() to make sure the position is correct.\n        this._ensurePosition();\n\n        const firstInput = first.input;\n        const lastInput = last.input;\n        const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n\n        if (firstInput && lastInput && element) {\n          let toFocus;\n\n          if (backwards) {\n            firstInput.tabIndex = 0;\n            toFocus = firstInput;\n          } else {\n            lastInput.tabIndex = 0;\n            toFocus = lastInput;\n          }\n\n          if (toFocus) {\n            nativeFocus(toFocus);\n          }\n        }\n      }\n    };\n    /**\r\n     * Prepares to move focus out of the given element by focusing\r\n     * one of the dummy inputs and setting the `useDefaultAction` flag\r\n     * @param backwards focus moving to an element behind the given element\r\n     */\n\n\n    this.moveOutWithDefaultAction = (backwards, relatedEvent) => {\n      var _a;\n\n      const first = this._firstDummy;\n      const last = this._lastDummy;\n\n      if (first && last) {\n        // For the sake of performance optimization, the dummy input\n        // position in the DOM updates asynchronously from the DOM change.\n        // Calling _ensurePosition() to make sure the position is correct.\n        this._ensurePosition();\n\n        const firstInput = first.input;\n        const lastInput = last.input;\n        const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n\n        if (firstInput && lastInput && element) {\n          let toFocus;\n\n          if (backwards) {\n            if (!first.isOutside && this._tabster.focusable.isFocusable(element, true, true, true)) {\n              toFocus = element;\n            } else {\n              first.useDefaultAction = true;\n              firstInput.tabIndex = 0;\n              toFocus = firstInput;\n            }\n          } else {\n            last.useDefaultAction = true;\n            lastInput.tabIndex = 0;\n            toFocus = lastInput;\n          }\n\n          if (toFocus && dispatchMoveFocusEvent({\n            by: \"root\",\n            owner: element,\n            next: null,\n            relatedEvent\n          })) {\n            nativeFocus(toFocus);\n          }\n        }\n      }\n    };\n\n    this.setTabbable = (manager, tabbable) => {\n      var _a, _b;\n\n      for (const w of this._wrappers) {\n        if (w.manager === manager) {\n          w.tabbable = tabbable;\n          break;\n        }\n      }\n\n      const wrapper = this._getCurrent();\n\n      if (wrapper) {\n        const tabIndex = wrapper.tabbable ? 0 : -1;\n        let input = (_a = this._firstDummy) === null || _a === void 0 ? void 0 : _a.input;\n\n        if (input) {\n          input.tabIndex = tabIndex;\n        }\n\n        input = (_b = this._lastDummy) === null || _b === void 0 ? void 0 : _b.input;\n\n        if (input) {\n          input.tabIndex = tabIndex;\n        }\n      }\n\n      if (process.env.NODE_ENV === 'development') {\n        this._firstDummy && setDummyInputDebugValue(this._firstDummy, this._wrappers);\n        this._lastDummy && setDummyInputDebugValue(this._lastDummy, this._wrappers);\n      }\n    };\n    /**\r\n     * Adds dummy inputs as the first and last child of the given element\r\n     * Called each time the children under the element is mutated\r\n     */\n\n\n    this._addDummyInputs = () => {\n      if (this._addTimer) {\n        return;\n      }\n\n      this._addTimer = this._getWindow().setTimeout(() => {\n        delete this._addTimer;\n\n        this._ensurePosition();\n\n        if (process.env.NODE_ENV === 'development') {\n          this._firstDummy && setDummyInputDebugValue(this._firstDummy, this._wrappers);\n          this._lastDummy && setDummyInputDebugValue(this._lastDummy, this._wrappers);\n        }\n\n        this._addTransformOffsets();\n      }, 0);\n    };\n\n    this._addTransformOffsets = () => {\n      this._tabster._dummyObserver.updatePositions(this._computeTransformOffsets);\n    };\n\n    this._computeTransformOffsets = scrollTopLeftCache => {\n      var _a, _b;\n\n      const from = ((_a = this._firstDummy) === null || _a === void 0 ? void 0 : _a.input) || ((_b = this._lastDummy) === null || _b === void 0 ? void 0 : _b.input);\n      const transformElements = this._transformElements;\n      const newTransformElements = new Set();\n      let scrollTop = 0;\n      let scrollLeft = 0;\n\n      const win = this._getWindow();\n\n      for (let element = from; element && element.nodeType === Node.ELEMENT_NODE; element = dom.getParentElement(element)) {\n        let scrollTopLeft = scrollTopLeftCache.get(element); // getComputedStyle() and element.scrollLeft/Top() cause style recalculation,\n        // so we cache the result across all elements in the current bulk.\n\n        if (scrollTopLeft === undefined) {\n          const transform = win.getComputedStyle(element).transform;\n\n          if (transform && transform !== \"none\") {\n            scrollTopLeft = {\n              scrollTop: element.scrollTop,\n              scrollLeft: element.scrollLeft\n            };\n          }\n\n          scrollTopLeftCache.set(element, scrollTopLeft || null);\n        }\n\n        if (scrollTopLeft) {\n          newTransformElements.add(element);\n\n          if (!transformElements.has(element)) {\n            element.addEventListener(\"scroll\", this._addTransformOffsets);\n          }\n\n          scrollTop += scrollTopLeft.scrollTop;\n          scrollLeft += scrollTopLeft.scrollLeft;\n        }\n      }\n\n      for (const el of transformElements) {\n        if (!newTransformElements.has(el)) {\n          el.removeEventListener(\"scroll\", this._addTransformOffsets);\n        }\n      }\n\n      this._transformElements = newTransformElements;\n      return () => {\n        var _a, _b;\n\n        (_a = this._firstDummy) === null || _a === void 0 ? void 0 : _a.setTopLeft(scrollTop, scrollLeft);\n        (_b = this._lastDummy) === null || _b === void 0 ? void 0 : _b.setTopLeft(scrollTop, scrollLeft);\n      };\n    };\n\n    const el = element.get();\n\n    if (!el) {\n      throw new Error(\"No element\");\n    }\n\n    this._tabster = tabster;\n    this._getWindow = tabster.getWindow;\n    this._callForDefaultAction = callForDefaultAction;\n    const instance = el.__tabsterDummy;\n\n    (instance || this)._wrappers.push({\n      manager,\n      priority,\n      tabbable: true\n    });\n\n    if (instance) {\n      if (process.env.NODE_ENV === 'development') {\n        this._firstDummy && setDummyInputDebugValue(this._firstDummy, instance._wrappers);\n        this._lastDummy && setDummyInputDebugValue(this._lastDummy, instance._wrappers);\n      }\n\n      return instance;\n    }\n\n    el.__tabsterDummy = this; // Some elements allow only specific types of direct descendants and we need to\n    // put our dummy inputs inside or outside of the element accordingly.\n\n    const forcedDummyPosition = sys === null || sys === void 0 ? void 0 : sys.dummyInputsPosition;\n    const tagName = el.tagName;\n    this._isOutside = !forcedDummyPosition ? (outsideByDefault || tagName === \"UL\" || tagName === \"OL\" || tagName === \"TABLE\") && !(tagName === \"LI\" || tagName === \"TD\" || tagName === \"TH\") : forcedDummyPosition === SysDummyInputsPositions.Outside;\n    this._firstDummy = new DummyInput(this._getWindow, this._isOutside, {\n      isFirst: true\n    }, element);\n    this._lastDummy = new DummyInput(this._getWindow, this._isOutside, {\n      isFirst: false\n    }, element); // We will be checking dummy input parents to see if their child list have changed.\n    // So, it is enough to have just one of the inputs observed, because\n    // both dummy inputs always have the same parent.\n\n    const dummyElement = this._firstDummy.input;\n    dummyElement && tabster._dummyObserver.add(dummyElement, this._addDummyInputs);\n    this._firstDummy.onFocusIn = this._onFocusIn;\n    this._firstDummy.onFocusOut = this._onFocusOut;\n    this._lastDummy.onFocusIn = this._onFocusIn;\n    this._lastDummy.onFocusOut = this._onFocusOut;\n    this._element = element;\n\n    this._addDummyInputs();\n  }\n\n  dispose(manager, force) {\n    var _a, _b, _c, _d;\n\n    const wrappers = this._wrappers = this._wrappers.filter(w => w.manager !== manager && !force);\n\n    if (process.env.NODE_ENV === 'development') {\n      this._firstDummy && setDummyInputDebugValue(this._firstDummy, wrappers);\n      this._lastDummy && setDummyInputDebugValue(this._lastDummy, wrappers);\n    }\n\n    if (wrappers.length === 0) {\n      delete ((_a = this._element) === null || _a === void 0 ? void 0 : _a.get()).__tabsterDummy;\n\n      for (const el of this._transformElements) {\n        el.removeEventListener(\"scroll\", this._addTransformOffsets);\n      }\n\n      this._transformElements.clear();\n\n      const win = this._getWindow();\n\n      if (this._addTimer) {\n        win.clearTimeout(this._addTimer);\n        delete this._addTimer;\n      }\n\n      const dummyElement = (_b = this._firstDummy) === null || _b === void 0 ? void 0 : _b.input;\n      dummyElement && this._tabster._dummyObserver.remove(dummyElement);\n      (_c = this._firstDummy) === null || _c === void 0 ? void 0 : _c.dispose();\n      (_d = this._lastDummy) === null || _d === void 0 ? void 0 : _d.dispose();\n    }\n  }\n\n  _onFocus(isIn, dummyInput, isBackward, relatedTarget) {\n    var _a;\n\n    const wrapper = this._getCurrent();\n\n    if (wrapper && (!dummyInput.useDefaultAction || this._callForDefaultAction)) {\n      (_a = wrapper.manager.getHandler(isIn)) === null || _a === void 0 ? void 0 : _a(dummyInput, isBackward, relatedTarget);\n    }\n  }\n\n  _getCurrent() {\n    this._wrappers.sort((a, b) => {\n      if (a.tabbable !== b.tabbable) {\n        return a.tabbable ? -1 : 1;\n      }\n\n      return a.priority - b.priority;\n    });\n\n    return this._wrappers[0];\n  }\n\n  _ensurePosition() {\n    var _a, _b, _c;\n\n    const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n    const firstDummyInput = (_b = this._firstDummy) === null || _b === void 0 ? void 0 : _b.input;\n    const lastDummyInput = (_c = this._lastDummy) === null || _c === void 0 ? void 0 : _c.input;\n\n    if (!element || !firstDummyInput || !lastDummyInput) {\n      return;\n    }\n\n    if (this._isOutside) {\n      const elementParent = dom.getParentNode(element);\n\n      if (elementParent) {\n        const nextSibling = dom.getNextSibling(element);\n\n        if (nextSibling !== lastDummyInput) {\n          dom.insertBefore(elementParent, lastDummyInput, nextSibling);\n        }\n\n        if (dom.getPreviousElementSibling(element) !== firstDummyInput) {\n          dom.insertBefore(elementParent, firstDummyInput, element);\n        }\n      }\n    } else {\n      if (dom.getLastElementChild(element) !== lastDummyInput) {\n        dom.appendChild(element, lastDummyInput);\n      }\n\n      const firstElementChild = dom.getFirstElementChild(element);\n\n      if (firstElementChild && firstElementChild !== firstDummyInput && firstElementChild.parentNode) {\n        dom.insertBefore(firstElementChild.parentNode, firstDummyInput, firstElementChild);\n      }\n    }\n  }\n\n}\n\nfunction getLastChild$2(container) {\n  let lastChild = null;\n\n  for (let i = dom.getLastElementChild(container); i; i = dom.getLastElementChild(i)) {\n    lastChild = i;\n  }\n\n  return lastChild || undefined;\n}\nfunction getAdjacentElement(from, prev) {\n  let cur = from;\n  let adjacent = null;\n\n  while (cur && !adjacent) {\n    adjacent = prev ? dom.getPreviousElementSibling(cur) : dom.getNextElementSibling(cur);\n    cur = dom.getParentElement(cur);\n  }\n\n  return adjacent || undefined;\n}\nfunction triggerEvent(target, name, detail) {\n  const event = new CustomEvent(name, {\n    bubbles: true,\n    cancelable: true,\n    composed: true,\n    detail\n  }); // For the sake of backward compatibility, we're adding `details` property.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n  event.details = detail;\n  target.dispatchEvent(event);\n  return !event.defaultPrevented;\n}\nfunction dispatchMoveFocusEvent(details) {\n  return triggerEvent(details.owner, MoveFocusEventName, details);\n}\nfunction dispatchMoverMoveFocusEvent(target, key) {\n  return triggerEvent(target, MoverMoveFocusEventName, {\n    key\n  });\n}\nfunction dispatchGroupperMoveFocusEvent(target, action) {\n  return triggerEvent(target, GroupperMoveFocusEventName, {\n    action\n  });\n}\nfunction augmentAttribute(tabster, element, name, value // Restore original value when undefined.\n) {\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const entry = tabster.storageEntry(element, true);\n  let ret = false;\n\n  if (!entry.aug) {\n    if (value === undefined) {\n      return ret;\n    }\n\n    entry.aug = {};\n  }\n\n  if (value === undefined) {\n    if (name in entry.aug) {\n      const origVal = entry.aug[name];\n      delete entry.aug[name];\n\n      if (origVal === null) {\n        element.removeAttribute(name);\n      } else {\n        element.setAttribute(name, origVal);\n      }\n\n      ret = true;\n    }\n  } else {\n    let origValue;\n\n    if (!(name in entry.aug)) {\n      origValue = element.getAttribute(name);\n    }\n\n    if (origValue !== undefined && origValue !== value) {\n      entry.aug[name] = origValue;\n\n      if (value === null) {\n        element.removeAttribute(name);\n      } else {\n        element.setAttribute(name, value);\n      }\n\n      ret = true;\n    }\n  }\n\n  if (value === undefined && Object.keys(entry.aug).length === 0) {\n    delete entry.aug;\n    tabster.storageEntry(element, false);\n  }\n\n  return ret;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction getTabsterAttribute(props, plain) {\n  const attr = JSON.stringify(props);\n\n  if (plain === true) {\n    return attr;\n  }\n\n  return {\n    [TabsterAttributeName]: attr\n  };\n}\n/**\r\n * Updates Tabster props object with new props.\r\n * @param element an element to set data-tabster attribute on.\r\n * @param props current Tabster props to update.\r\n * @param newProps new Tabster props to add.\r\n *  When the value of a property in newProps is undefined, the property\r\n *  will be removed from the attribute.\r\n */\n\nfunction mergeTabsterProps(props, newProps) {\n  for (const key of Object.keys(newProps)) {\n    const value = newProps[key];\n\n    if (value) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      props[key] = value;\n    } else {\n      delete props[key];\n    }\n  }\n}\n/**\r\n * Sets or updates Tabster attribute of the element.\r\n * @param element an element to set data-tabster attribute on.\r\n * @param newProps new Tabster props to set.\r\n * @param update if true, newProps will be merged with the existing props.\r\n *  When true and the value of a property in newProps is undefined, the property\r\n *  will be removed from the attribute.\r\n */\n\nfunction setTabsterAttribute(element, newProps, update) {\n  let props;\n\n  if (update) {\n    const attr = element.getAttribute(TabsterAttributeName);\n\n    if (attr) {\n      try {\n        props = JSON.parse(attr);\n      } catch (e) {\n        if (process.env.NODE_ENV === 'development') {\n          console.error(`data-tabster attribute error: ${e}`, element);\n        }\n      }\n    }\n  }\n\n  if (!props) {\n    props = {};\n  }\n\n  mergeTabsterProps(props, newProps);\n\n  if (Object.keys(props).length > 0) {\n    element.setAttribute(TabsterAttributeName, getTabsterAttribute(props, true));\n  } else {\n    element.removeAttribute(TabsterAttributeName);\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nfunction _setInformativeStyle$3(weakElement, remove, id) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-root\");\n      } else {\n        element.style.setProperty(\"--tabster-root\", id + \",\");\n      }\n    }\n  }\n}\n\nclass RootDummyManager extends DummyInputManager {\n  constructor(tabster, element, setFocused, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Root, sys, undefined, true);\n\n    this._onDummyInputFocus = dummyInput => {\n      var _a;\n\n      if (dummyInput.useDefaultAction) {\n        // When we've reached the last focusable element, we want to let the browser\n        // to move the focus outside of the page. In order to do that we're synchronously\n        // calling focus() of the dummy input from the Tab key handler and allowing\n        // the default action to move the focus out.\n        this._setFocused(false);\n      } else {\n        // The only way a dummy input gets focused is during the keyboard navigation.\n        this._tabster.keyboardNavigation.setNavigatingWithKeyboard(true);\n\n        const element = this._element.get();\n\n        if (element) {\n          this._setFocused(true);\n\n          const toFocus = this._tabster.focusedElement.getFirstOrLastTabbable(dummyInput.isFirst, {\n            container: element,\n            ignoreAccessibility: true\n          });\n\n          if (toFocus) {\n            nativeFocus(toFocus);\n            return;\n          }\n        }\n\n        (_a = dummyInput.input) === null || _a === void 0 ? void 0 : _a.blur();\n      }\n    };\n\n    this._setHandlers(this._onDummyInputFocus);\n\n    this._tabster = tabster;\n    this._setFocused = setFocused;\n  }\n\n}\n\nclass Root extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys) {\n    super(tabster, element, props);\n    this._isFocused = false;\n\n    this._setFocused = hasFocused => {\n      var _a;\n\n      if (this._setFocusedTimer) {\n        this._tabster.getWindow().clearTimeout(this._setFocusedTimer);\n\n        delete this._setFocusedTimer;\n      }\n\n      if (this._isFocused === hasFocused) {\n        return;\n      }\n\n      const element = this._element.get();\n\n      if (element) {\n        if (hasFocused) {\n          this._isFocused = true;\n          (_a = this._dummyManager) === null || _a === void 0 ? void 0 : _a.setTabbable(false);\n          triggerEvent(this._tabster.root.eventTarget, \"focus\", {\n            element\n          });\n        } else {\n          this._setFocusedTimer = this._tabster.getWindow().setTimeout(() => {\n            var _a;\n\n            delete this._setFocusedTimer;\n            this._isFocused = false;\n            (_a = this._dummyManager) === null || _a === void 0 ? void 0 : _a.setTabbable(true);\n            triggerEvent(this._tabster.root.eventTarget, \"blur\", {\n              element\n            });\n          }, 0);\n        }\n      }\n    };\n\n    this._onFocusIn = event => {\n      const getParent = this._tabster.getParent;\n\n      const rootElement = this._element.get();\n\n      let curElement = event.composedPath()[0];\n\n      do {\n        if (curElement === rootElement) {\n          this._setFocused(true);\n\n          return;\n        }\n\n        curElement = curElement && getParent(curElement);\n      } while (curElement);\n    };\n\n    this._onFocusOut = () => {\n      this._setFocused(false);\n    };\n\n    this._onDispose = onDispose;\n    const win = tabster.getWindow;\n    this.uid = getElementUId(win, element);\n    this._sys = sys;\n\n    if (tabster.controlTab || tabster.rootDummyInputs) {\n      this.addDummyInputs();\n    }\n\n    const w = win();\n    const doc = w.document;\n    doc.addEventListener(KEYBORG_FOCUSIN, this._onFocusIn);\n    doc.addEventListener(KEYBORG_FOCUSOUT, this._onFocusOut);\n\n    this._add();\n  }\n\n  addDummyInputs() {\n    if (!this._dummyManager) {\n      this._dummyManager = new RootDummyManager(this._tabster, this._element, this._setFocused, this._sys);\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    this._onDispose(this);\n\n    const win = this._tabster.getWindow();\n\n    const doc = win.document;\n    doc.removeEventListener(KEYBORG_FOCUSIN, this._onFocusIn);\n    doc.removeEventListener(KEYBORG_FOCUSOUT, this._onFocusOut);\n\n    if (this._setFocusedTimer) {\n      win.clearTimeout(this._setFocusedTimer);\n      delete this._setFocusedTimer;\n    }\n\n    (_a = this._dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n\n    this._remove();\n  }\n\n  moveOutWithDefaultAction(isBackward, relatedEvent) {\n    const dummyManager = this._dummyManager;\n\n    if (dummyManager) {\n      dummyManager.moveOutWithDefaultAction(isBackward, relatedEvent);\n    } else {\n      const el = this.getElement();\n\n      if (el) {\n        RootDummyManager.moveWithPhantomDummy(this._tabster, el, true, isBackward, relatedEvent);\n      }\n    }\n  }\n\n  _add() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$3(this._element, false, this.uid);\n    }\n  }\n\n  _remove() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$3(this._element, true);\n    }\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass RootAPI {\n  constructor(tabster, autoRoot) {\n    this._autoRootWaiting = false;\n    this._roots = {};\n    this._forceDummy = false;\n    this.rootById = {};\n\n    this._autoRootCreate = () => {\n      var _a;\n\n      const doc = this._win().document;\n\n      const body = doc.body;\n\n      if (body) {\n        this._autoRootUnwait(doc);\n\n        const props = this._autoRoot;\n\n        if (props) {\n          setTabsterAttribute(body, {\n            root: props\n          }, true);\n          updateTabsterByAttribute(this._tabster, body);\n          return (_a = getTabsterOnElement(this._tabster, body)) === null || _a === void 0 ? void 0 : _a.root;\n        }\n      } else if (!this._autoRootWaiting) {\n        this._autoRootWaiting = true;\n        doc.addEventListener(\"readystatechange\", this._autoRootCreate);\n      }\n\n      return undefined;\n    };\n\n    this._onRootDispose = root => {\n      delete this._roots[root.id];\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._autoRoot = autoRoot;\n    this.eventTarget = createEventTarget(this._win);\n    tabster.queueInit(() => {\n      if (this._autoRoot) {\n        this._autoRootCreate();\n      }\n    });\n  }\n\n  _autoRootUnwait(doc) {\n    doc.removeEventListener(\"readystatechange\", this._autoRootCreate);\n    this._autoRootWaiting = false;\n  }\n\n  dispose() {\n    const win = this._win();\n\n    this._autoRootUnwait(win.document);\n\n    delete this._autoRoot;\n    Object.keys(this._roots).forEach(rootId => {\n      if (this._roots[rootId]) {\n        this._roots[rootId].dispose();\n\n        delete this._roots[rootId];\n      }\n    });\n    this.rootById = {};\n  }\n\n  createRoot(element, props, sys) {\n    if (process.env.NODE_ENV === 'development') ;\n\n    const newRoot = new Root(this._tabster, element, this._onRootDispose, props, sys);\n    this._roots[newRoot.id] = newRoot;\n\n    if (this._forceDummy) {\n      newRoot.addDummyInputs();\n    }\n\n    return newRoot;\n  }\n\n  addDummyInputs() {\n    this._forceDummy = true;\n    const roots = this._roots;\n\n    for (const id of Object.keys(roots)) {\n      roots[id].addDummyInputs();\n    }\n  }\n\n  static getRootByUId(getWindow, id) {\n    const tabster = getWindow().__tabsterInstance;\n\n    return tabster && tabster.root.rootById[id];\n  }\n  /**\r\n   * Fetches the tabster context for an element walking up its ancestors\r\n   *\r\n   * @param tabster Tabster instance\r\n   * @param element The element the tabster context should represent\r\n   * @param options Additional options\r\n   * @returns undefined if the element is not a child of a tabster root, otherwise all applicable tabster behaviours and configurations\r\n   */\n\n\n  static getTabsterContext(tabster, element, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    var _a, _b, _c, _d;\n\n    if (!element.ownerDocument) {\n      return undefined;\n    }\n\n    const {\n      checkRtl,\n      referenceElement\n    } = options;\n    const getParent = tabster.getParent; // Normally, the initialization starts on the next tick after the tabster\n    // instance creation. However, if the application starts using it before\n    // the next tick, we need to make sure the initialization is done.\n\n    tabster.drainInitQueue();\n    let root;\n    let modalizer;\n    let groupper;\n    let mover;\n    let excludedFromMover = false;\n    let groupperBeforeMover;\n    let modalizerInGroupper;\n    let dirRightToLeft;\n    let uncontrolled;\n    let curElement = referenceElement || element;\n    const ignoreKeydown = {};\n\n    while (curElement && (!root || checkRtl)) {\n      const tabsterOnElement = getTabsterOnElement(tabster, curElement);\n\n      if (checkRtl && dirRightToLeft === undefined) {\n        const dir = curElement.dir;\n\n        if (dir) {\n          dirRightToLeft = dir.toLowerCase() === \"rtl\";\n        }\n      }\n\n      if (!tabsterOnElement) {\n        curElement = getParent(curElement);\n        continue;\n      }\n\n      const tagName = curElement.tagName;\n\n      if (tabsterOnElement.uncontrolled || tagName === \"IFRAME\" || tagName === \"WEBVIEW\") {\n        uncontrolled = curElement;\n      }\n\n      if (!mover && ((_a = tabsterOnElement.focusable) === null || _a === void 0 ? void 0 : _a.excludeFromMover) && !groupper) {\n        excludedFromMover = true;\n      }\n\n      const curModalizer = tabsterOnElement.modalizer;\n      const curGroupper = tabsterOnElement.groupper;\n      const curMover = tabsterOnElement.mover;\n\n      if (!modalizer && curModalizer) {\n        modalizer = curModalizer;\n      }\n\n      if (!groupper && curGroupper && (!modalizer || curModalizer)) {\n        if (modalizer) {\n          // Modalizer dominates the groupper when they are on the same node and the groupper is active.\n          if (!curGroupper.isActive() && curGroupper.getProps().tabbability && modalizer.userId !== ((_b = tabster.modalizer) === null || _b === void 0 ? void 0 : _b.activeId)) {\n            modalizer = undefined;\n            groupper = curGroupper;\n          }\n\n          modalizerInGroupper = curGroupper;\n        } else {\n          groupper = curGroupper;\n        }\n      }\n\n      if (!mover && curMover && (!modalizer || curModalizer) && (!curGroupper || curElement !== element)) {\n        mover = curMover;\n        groupperBeforeMover = !!groupper && groupper !== curGroupper;\n      }\n\n      if (tabsterOnElement.root) {\n        root = tabsterOnElement.root;\n      }\n\n      if ((_c = tabsterOnElement.focusable) === null || _c === void 0 ? void 0 : _c.ignoreKeydown) {\n        Object.assign(ignoreKeydown, tabsterOnElement.focusable.ignoreKeydown);\n      }\n\n      curElement = getParent(curElement);\n    } // No root element could be found, try to get an auto root\n\n\n    if (!root) {\n      const rootAPI = tabster.root;\n      const autoRoot = rootAPI._autoRoot;\n\n      if (autoRoot) {\n        if ((_d = element.ownerDocument) === null || _d === void 0 ? void 0 : _d.body) {\n          root = rootAPI._autoRootCreate();\n        }\n      }\n    }\n\n    if (groupper && !mover) {\n      groupperBeforeMover = true;\n    }\n\n    if (process.env.NODE_ENV === 'development' && !root) {\n      if (modalizer || groupper || mover) {\n        console.error(\"Tabster Root is required for Mover, Groupper and Modalizer to work.\");\n      }\n    }\n\n    const shouldIgnoreKeydown = event => !!ignoreKeydown[event.key];\n\n    return root ? {\n      root,\n      modalizer,\n      groupper,\n      mover,\n      groupperBeforeMover,\n      modalizerInGroupper,\n      rtl: checkRtl ? !!dirRightToLeft : undefined,\n      uncontrolled,\n      excludedFromMover,\n      ignoreKeydown: shouldIgnoreKeydown\n    } : undefined;\n  }\n\n  static getRoot(tabster, element) {\n    var _a;\n\n    const getParent = tabster.getParent;\n\n    for (let el = element; el; el = getParent(el)) {\n      const root = (_a = getTabsterOnElement(tabster, el)) === null || _a === void 0 ? void 0 : _a.root;\n\n      if (root) {\n        return root;\n      }\n    }\n\n    return undefined;\n  }\n\n  onRoot(root, removed) {\n    if (removed) {\n      delete this.rootById[root.uid];\n    } else {\n      this.rootById[root.uid] = root;\n    }\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _containerHistoryLength = 10;\nclass DeloserItemBase {}\nclass DeloserItem extends DeloserItemBase {\n  constructor(tabster, deloser) {\n    super();\n    this.uid = deloser.uid;\n    this._tabster = tabster;\n    this._deloser = deloser;\n  }\n\n  belongsTo(deloser) {\n    return deloser === this._deloser;\n  }\n\n  unshift(element) {\n    this._deloser.unshift(element);\n  }\n\n  async focusAvailable() {\n    const available = this._deloser.findAvailable();\n\n    return available ? this._tabster.focusedElement.focus(available) : false;\n  }\n\n  async resetFocus() {\n    const getWindow = this._tabster.getWindow;\n    return getPromise(getWindow).resolve(this._deloser.resetFocus());\n  }\n\n}\nclass DeloserHistoryByRootBase {\n  constructor(tabster, rootUId) {\n    this._history = [];\n    this._tabster = tabster;\n    this.rootUId = rootUId;\n  }\n\n  getLength() {\n    return this._history.length;\n  }\n\n  removeDeloser(deloser) {\n    this._history = this._history.filter(c => !c.belongsTo(deloser));\n  }\n\n  hasDeloser(deloser) {\n    return this._history.some(d => d.belongsTo(deloser));\n  }\n\n}\n\nclass DeloserHistoryByRoot extends DeloserHistoryByRootBase {\n  unshiftToDeloser(deloser, element) {\n    let item;\n\n    for (let i = 0; i < this._history.length; i++) {\n      if (this._history[i].belongsTo(deloser)) {\n        item = this._history[i];\n\n        this._history.splice(i, 1);\n\n        break;\n      }\n    }\n\n    if (!item) {\n      item = new DeloserItem(this._tabster, deloser);\n    }\n\n    item.unshift(element);\n\n    this._history.unshift(item);\n\n    this._history.splice(_containerHistoryLength, this._history.length - _containerHistoryLength);\n  }\n\n  async focusAvailable(from) {\n    let skip = !!from;\n\n    for (const i of this._history) {\n      if (from && i.belongsTo(from)) {\n        skip = false;\n      }\n\n      if (!skip && (await i.focusAvailable())) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  async resetFocus(from) {\n    let skip = !!from;\n    const resetQueue = {};\n\n    for (const i of this._history) {\n      if (from && i.belongsTo(from)) {\n        skip = false;\n      }\n\n      if (!skip && !resetQueue[i.uid]) {\n        resetQueue[i.uid] = i;\n      }\n    } // Nothing is found, at least try to reset.\n\n\n    for (const id of Object.keys(resetQueue)) {\n      if (await resetQueue[id].resetFocus()) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\nclass DeloserHistory {\n  constructor(tabster) {\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    this._history = [];\n    this._tabster = tabster;\n  }\n\n  dispose() {\n    this._history = [];\n  }\n\n  process(element) {\n    var _a;\n\n    const ctx = RootAPI.getTabsterContext(this._tabster, element);\n    const rootUId = ctx && ctx.root.uid;\n    const deloser = DeloserAPI.getDeloser(this._tabster, element);\n\n    if (!rootUId || !deloser) {\n      return undefined;\n    }\n\n    const historyByRoot = this.make(rootUId, () => new DeloserHistoryByRoot(this._tabster, rootUId));\n\n    if (!ctx || !ctx.modalizer || ((_a = ctx.modalizer) === null || _a === void 0 ? void 0 : _a.isActive())) {\n      historyByRoot.unshiftToDeloser(deloser, element);\n    }\n\n    return deloser;\n  }\n\n  make(rootUId, createInstance) {\n    let historyByRoot;\n\n    for (let i = 0; i < this._history.length; i++) {\n      const hbr = this._history[i];\n\n      if (hbr.rootUId === rootUId) {\n        historyByRoot = hbr;\n\n        this._history.splice(i, 1);\n\n        break;\n      }\n    }\n\n    if (!historyByRoot) {\n      historyByRoot = createInstance();\n    }\n\n    this._history.unshift(historyByRoot);\n\n    this._history.splice(_containerHistoryLength, this._history.length - _containerHistoryLength);\n\n    return historyByRoot;\n  }\n\n  removeDeloser(deloser) {\n    this._history.forEach(i => {\n      i.removeDeloser(deloser);\n    });\n\n    this._history = this._history.filter(i => i.getLength() > 0);\n  }\n\n  async focusAvailable(from) {\n    let skip = !!from;\n\n    for (const h of this._history) {\n      if (from && h.hasDeloser(from)) {\n        skip = false;\n      }\n\n      if (!skip && (await h.focusAvailable(from))) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  async resetFocus(from) {\n    let skip = !!from;\n\n    for (const h of this._history) {\n      if (from && h.hasDeloser(from)) {\n        skip = false;\n      }\n\n      if (!skip && (await h.resetFocus(from))) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\nfunction _setInformativeStyle$2(weakElement, remove, isActive, snapshotIndex) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-deloser\");\n      } else {\n        element.style.setProperty(\"--tabster-deloser\", (isActive ? \"active\" : \"inactive\") + \",\" + (\"snapshot-\" + snapshotIndex));\n      }\n    }\n  }\n}\n\nfunction buildElementSelector(element, withClass, withIndex) {\n  const selector = [];\n  const escapeRegExp = /(:|\\.|\\[|\\]|,|=|@)/g;\n  const escapeReplaceValue = \"\\\\$1\";\n  const elementId = element.getAttribute(\"id\");\n\n  if (elementId) {\n    selector.push(\"#\" + elementId.replace(escapeRegExp, escapeReplaceValue));\n  }\n\n  if (withClass !== false && element.className) {\n    element.className.split(\" \").forEach(cls => {\n      cls = cls.trim();\n\n      if (cls) {\n        selector.push(\".\" + cls.replace(escapeRegExp, escapeReplaceValue));\n      }\n    });\n  }\n\n  let index = 0;\n  let el;\n\n  if (withIndex !== false && selector.length === 0) {\n    el = element;\n\n    while (el) {\n      index++;\n      el = el.previousElementSibling;\n    }\n\n    selector.unshift(\":nth-child(\" + index + \")\");\n  }\n\n  selector.unshift(element.tagName.toLowerCase());\n  return selector.join(\"\");\n}\n\nfunction buildSelector(element) {\n  if (!documentContains(element.ownerDocument, element)) {\n    return undefined;\n  }\n\n  const selector = [buildElementSelector(element)];\n  let node = dom.getParentNode(element);\n\n  while (node && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {\n    // Stop at the shadow root as cross shadow selectors won't work.\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const isBody = node.tagName === \"BODY\";\n      selector.unshift(buildElementSelector(node, false, !isBody));\n\n      if (isBody) {\n        break;\n      }\n    }\n\n    node = dom.getParentNode(node);\n  }\n\n  return selector.join(\" \");\n}\n\nclass Deloser extends TabsterPart {\n  constructor(tabster, element, onDispose, props) {\n    super(tabster, element, props);\n    this._isActive = false;\n    this._history = [[]];\n    this._snapshotIndex = 0;\n\n    this.isActive = () => {\n      return this._isActive;\n    };\n\n    this.setSnapshot = index => {\n      this._snapshotIndex = index;\n\n      if (this._history.length > index + 1) {\n        this._history.splice(index + 1, this._history.length - index - 1);\n      }\n\n      if (!this._history[index]) {\n        this._history[index] = [];\n      }\n\n      if (process.env.NODE_ENV === 'development') {\n        _setInformativeStyle$2(this._element, false, this._isActive, this._snapshotIndex);\n      }\n    };\n\n    this.focusFirst = () => {\n      const e = this._element.get();\n\n      return !!e && this._tabster.focusedElement.focusFirst({\n        container: e\n      });\n    };\n\n    this.focusDefault = () => {\n      const e = this._element.get();\n\n      return !!e && this._tabster.focusedElement.focusDefault(e);\n    };\n\n    this.resetFocus = () => {\n      const e = this._element.get();\n\n      return !!e && this._tabster.focusedElement.resetFocus(e);\n    };\n\n    this.clearHistory = preserveExisting => {\n      const element = this._element.get();\n\n      if (!element) {\n        this._history[this._snapshotIndex] = [];\n        return;\n      }\n\n      this._history[this._snapshotIndex] = this._history[this._snapshotIndex].filter(we => {\n        const e = we.get();\n        return e && preserveExisting ? dom.nodeContains(element, e) : false;\n      });\n    };\n\n    this.uid = getElementUId(tabster.getWindow, element);\n    this._onDispose = onDispose;\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$2(this._element, false, this._isActive, this._snapshotIndex);\n    }\n  }\n\n  dispose() {\n    this._remove();\n\n    this._onDispose(this);\n\n    this._isActive = false;\n    this._snapshotIndex = 0;\n    this._props = {};\n    this._history = [];\n  }\n\n  setActive(active) {\n    this._isActive = active;\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$2(this._element, false, this._isActive, this._snapshotIndex);\n    }\n  }\n\n  getActions() {\n    return {\n      focusDefault: this.focusDefault,\n      focusFirst: this.focusFirst,\n      resetFocus: this.resetFocus,\n      clearHistory: this.clearHistory,\n      setSnapshot: this.setSnapshot,\n      isActive: this.isActive\n    };\n  }\n\n  unshift(element) {\n    let cur = this._history[this._snapshotIndex];\n    cur = this._history[this._snapshotIndex] = cur.filter(we => {\n      const e = we.get();\n      return e && e !== element;\n    });\n    cur.unshift(new WeakHTMLElement(this._tabster.getWindow, element, buildSelector(element)));\n\n    while (cur.length > _containerHistoryLength) {\n      cur.pop();\n    }\n  }\n\n  findAvailable() {\n    const element = this._element.get();\n\n    if (!element || !this._tabster.focusable.isVisible(element)) {\n      return null;\n    }\n\n    let restoreFocusOrder = this._props.restoreFocusOrder;\n    let available = null;\n    const ctx = RootAPI.getTabsterContext(this._tabster, element);\n\n    if (!ctx) {\n      return null;\n    }\n\n    const root = ctx.root;\n    const rootElement = root.getElement();\n\n    if (!rootElement) {\n      return null;\n    }\n\n    if (restoreFocusOrder === undefined) {\n      restoreFocusOrder = root.getProps().restoreFocusOrder;\n    }\n\n    if (restoreFocusOrder === RestoreFocusOrders.RootDefault) {\n      available = this._tabster.focusable.findDefault({\n        container: rootElement\n      });\n    }\n\n    if (!available && restoreFocusOrder === RestoreFocusOrders.RootFirst) {\n      available = this._findFirst(rootElement);\n    }\n\n    if (available) {\n      return available;\n    }\n\n    const availableInHistory = this._findInHistory();\n\n    const availableDefault = this._tabster.focusable.findDefault({\n      container: element\n    });\n\n    const availableFirst = this._findFirst(element);\n\n    if (availableInHistory && restoreFocusOrder === RestoreFocusOrders.History) {\n      return availableInHistory;\n    }\n\n    if (availableDefault && restoreFocusOrder === RestoreFocusOrders.DeloserDefault) {\n      return availableDefault;\n    }\n\n    if (availableFirst && restoreFocusOrder === RestoreFocusOrders.DeloserFirst) {\n      return availableFirst;\n    }\n\n    return availableDefault || availableInHistory || availableFirst || null;\n  }\n\n  customFocusLostHandler(element) {\n    return triggerEvent(element, DeloserEventName, this.getActions());\n  }\n\n  _findInHistory() {\n    const cur = this._history[this._snapshotIndex].slice(0);\n\n    this.clearHistory(true);\n\n    for (let i = 0; i < cur.length; i++) {\n      const we = cur[i];\n      const e = we.get();\n\n      const element = this._element.get();\n\n      if (e && element && dom.nodeContains(element, e)) {\n        if (this._tabster.focusable.isFocusable(e)) {\n          return e;\n        }\n      } else if (!this._props.noSelectorCheck) {\n        // Element is not in the DOM, try to locate the node by it's\n        // selector. This might return not exactly the right node,\n        // but it would be easily fixable by having more detailed selectors.\n        const selector = we.getData();\n\n        if (selector && element) {\n          let els;\n\n          try {\n            els = dom.querySelectorAll(element.ownerDocument, selector);\n          } catch (e) {\n            if (process.env.NODE_ENV === 'development') {\n              // This should never happen, unless there is some bug in buildElementSelector().\n              console.error(`Failed to querySelectorAll('${selector}')`);\n            }\n\n            continue;\n          }\n\n          for (let i = 0; i < els.length; i++) {\n            const el = els[i];\n\n            if (el && this._tabster.focusable.isFocusable(el)) {\n              return el;\n            }\n          }\n        }\n      }\n    }\n\n    return null;\n  }\n\n  _findFirst(element) {\n    if (this._tabster.keyboardNavigation.isNavigatingWithKeyboard()) {\n      const first = this._tabster.focusable.findFirst({\n        container: element,\n        useActiveModalizer: true\n      });\n\n      if (first) {\n        return first;\n      }\n    }\n\n    return null;\n  }\n\n  _remove() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$2(this._element, true);\n    }\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass DeloserAPI {\n  constructor(tabster, props) {\n    /**\r\n     * Tracks if focus is inside a deloser\r\n     */\n    this._inDeloser = false;\n    this._isRestoringFocus = false;\n    this._isPaused = false;\n\n    this._onFocus = e => {\n      if (this._restoreFocusTimer) {\n        this._win().clearTimeout(this._restoreFocusTimer);\n\n        this._restoreFocusTimer = undefined;\n      }\n\n      if (!e) {\n        this._scheduleRestoreFocus();\n\n        return;\n      }\n\n      const deloser = this._history.process(e);\n\n      if (deloser) {\n        this._activate(deloser);\n      } else {\n        this._deactivate();\n      }\n    };\n\n    this._onDeloserDispose = deloser => {\n      this._history.removeDeloser(deloser);\n\n      if (deloser.isActive()) {\n        this._scheduleRestoreFocus();\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._history = new DeloserHistory(tabster);\n    tabster.queueInit(() => {\n      this._tabster.focusedElement.subscribe(this._onFocus);\n\n      const doc = this._win().document;\n\n      const activeElement = dom.getActiveElement(doc);\n\n      if (activeElement && activeElement !== doc.body) {\n        // Adding currently focused element to the deloser history.\n        this._onFocus(activeElement);\n      }\n    });\n    const autoDeloser = props === null || props === void 0 ? void 0 : props.autoDeloser;\n\n    if (autoDeloser) {\n      this._autoDeloser = autoDeloser;\n    }\n  }\n\n  dispose() {\n    const win = this._win();\n\n    if (this._restoreFocusTimer) {\n      win.clearTimeout(this._restoreFocusTimer);\n      this._restoreFocusTimer = undefined;\n    }\n\n    if (this._autoDeloserInstance) {\n      this._autoDeloserInstance.dispose();\n\n      delete this._autoDeloserInstance;\n      delete this._autoDeloser;\n    }\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    this._history.dispose();\n\n    delete this._curDeloser;\n  }\n\n  createDeloser(element, props) {\n    var _a;\n\n    if (process.env.NODE_ENV === 'development') ;\n\n    const deloser = new Deloser(this._tabster, element, this._onDeloserDispose, props);\n\n    if (dom.nodeContains(element, (_a = this._tabster.focusedElement.getFocusedElement()) !== null && _a !== void 0 ? _a : null)) {\n      this._activate(deloser);\n    }\n\n    return deloser;\n  }\n\n  getActions(element) {\n    for (let e = element; e; e = dom.getParentElement(e)) {\n      const tabsterOnElement = getTabsterOnElement(this._tabster, e);\n\n      if (tabsterOnElement && tabsterOnElement.deloser) {\n        return tabsterOnElement.deloser.getActions();\n      }\n    }\n\n    return undefined;\n  }\n\n  pause() {\n    this._isPaused = true;\n\n    if (this._restoreFocusTimer) {\n      this._win().clearTimeout(this._restoreFocusTimer);\n\n      this._restoreFocusTimer = undefined;\n    }\n  }\n\n  resume(restore) {\n    this._isPaused = false;\n\n    if (restore) {\n      this._scheduleRestoreFocus();\n    }\n  }\n  /**\r\n   * Activates and sets the current deloser\r\n   */\n\n\n  _activate(deloser) {\n    const curDeloser = this._curDeloser;\n\n    if (curDeloser !== deloser) {\n      this._inDeloser = true;\n      curDeloser === null || curDeloser === void 0 ? void 0 : curDeloser.setActive(false);\n      deloser.setActive(true);\n      this._curDeloser = deloser;\n    }\n  }\n  /**\r\n   * Called when focus should no longer be in a deloser\r\n   */\n\n\n  _deactivate() {\n    var _a;\n\n    this._inDeloser = false;\n    (_a = this._curDeloser) === null || _a === void 0 ? void 0 : _a.setActive(false);\n    this._curDeloser = undefined;\n  }\n\n  _scheduleRestoreFocus(force) {\n    if (this._isPaused || this._isRestoringFocus) {\n      return;\n    }\n\n    const restoreFocus = async () => {\n      this._restoreFocusTimer = undefined;\n\n      const lastFocused = this._tabster.focusedElement.getLastFocusedElement();\n\n      if (!force && (this._isRestoringFocus || !this._inDeloser || !!(lastFocused === null || lastFocused === void 0 ? void 0 : lastFocused.offsetParent))) {\n        return;\n      }\n\n      const curDeloser = this._curDeloser;\n\n      if (curDeloser) {\n        if (lastFocused && curDeloser.customFocusLostHandler(lastFocused)) {\n          return;\n        }\n\n        const el = curDeloser.findAvailable();\n\n        if (el && this._tabster.focusedElement.focus(el)) {\n          return;\n        }\n      }\n\n      this._deactivate();\n\n      this._isRestoringFocus = true;\n\n      if (!(await this._history.focusAvailable(null))) {\n        await this._history.resetFocus(null);\n      }\n\n      this._isRestoringFocus = false;\n    };\n\n    if (force) {\n      restoreFocus();\n    } else {\n      this._restoreFocusTimer = this._win().setTimeout(restoreFocus, 100);\n    }\n  }\n\n  static getDeloser(tabster, element) {\n    var _a;\n\n    let root;\n\n    for (let e = element; e; e = dom.getParentElement(e)) {\n      const tabsterOnElement = getTabsterOnElement(tabster, e);\n\n      if (tabsterOnElement) {\n        if (!root) {\n          root = tabsterOnElement.root;\n        }\n\n        const deloser = tabsterOnElement.deloser;\n\n        if (deloser) {\n          return deloser;\n        }\n      }\n    }\n\n    const deloserAPI = tabster.deloser && tabster.deloser;\n\n    if (deloserAPI) {\n      if (deloserAPI._autoDeloserInstance) {\n        return deloserAPI._autoDeloserInstance;\n      }\n\n      const autoDeloserProps = deloserAPI._autoDeloser;\n\n      if (root && !deloserAPI._autoDeloserInstance && autoDeloserProps) {\n        const body = (_a = element.ownerDocument) === null || _a === void 0 ? void 0 : _a.body;\n\n        if (body) {\n          deloserAPI._autoDeloserInstance = new Deloser(tabster, body, tabster.deloser._onDeloserDispose, autoDeloserProps);\n        }\n      }\n\n      return deloserAPI._autoDeloserInstance;\n    }\n\n    return undefined;\n  }\n\n  static getHistory(instance) {\n    return instance._history;\n  }\n\n  static forceRestoreFocus(instance) {\n    instance._scheduleRestoreFocus(true);\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass Subscribable {\n  constructor() {\n    this._callbacks = [];\n  }\n\n  dispose() {\n    this._callbacks = [];\n    delete this._val;\n  }\n\n  subscribe(callback) {\n    const callbacks = this._callbacks;\n    const index = callbacks.indexOf(callback);\n\n    if (index < 0) {\n      callbacks.push(callback);\n    }\n  }\n\n  subscribeFirst(callback) {\n    const callbacks = this._callbacks;\n    const index = callbacks.indexOf(callback);\n\n    if (index >= 0) {\n      callbacks.splice(index, 1);\n    }\n\n    callbacks.unshift(callback);\n  }\n\n  unsubscribe(callback) {\n    const index = this._callbacks.indexOf(callback);\n\n    if (index >= 0) {\n      this._callbacks.splice(index, 1);\n    }\n  }\n\n  setVal(val, details) {\n    if (this._val === val) {\n      return;\n    }\n\n    this._val = val;\n\n    this._callCallbacks(val, details);\n  }\n\n  getVal() {\n    return this._val;\n  }\n\n  trigger(val, details) {\n    this._callCallbacks(val, details);\n  }\n\n  _callCallbacks(val, details) {\n    this._callbacks.forEach(callback => callback(val, details));\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _transactionTimeout = 1500;\nconst _pingTimeout = 3000;\nconst _targetIdUp = \"up\";\nconst CrossOriginTransactionTypes = {\n  Bootstrap: 1,\n  FocusElement: 2,\n  State: 3,\n  GetElement: 4,\n  RestoreFocusInDeloser: 5,\n  Ping: 6\n};\n\nclass CrossOriginDeloserItem extends DeloserItemBase {\n  constructor(tabster, deloser, trasactions) {\n    super();\n    this._deloser = deloser;\n    this._transactions = trasactions;\n  }\n\n  belongsTo(deloser) {\n    return deloser.deloserUId === this._deloser.deloserUId;\n  }\n\n  async focusAvailable() {\n    const data = { ...this._deloser,\n      reset: false\n    };\n    return this._transactions.beginTransaction(RestoreFocusInDeloserTransaction, data).then(value => !!value);\n  }\n\n  async resetFocus() {\n    const data = { ...this._deloser,\n      reset: true\n    };\n    return this._transactions.beginTransaction(RestoreFocusInDeloserTransaction, data).then(value => !!value);\n  }\n\n}\n\nclass CrossOriginDeloserHistoryByRoot extends DeloserHistoryByRootBase {\n  constructor(tabster, rootUId, transactions) {\n    super(tabster, rootUId);\n    this._transactions = transactions;\n  }\n\n  unshift(deloser) {\n    let item;\n\n    for (let i = 0; i < this._history.length; i++) {\n      if (this._history[i].belongsTo(deloser)) {\n        item = this._history[i];\n\n        this._history.splice(i, 1);\n\n        break;\n      }\n    }\n\n    if (!item) {\n      item = new CrossOriginDeloserItem(this._tabster, deloser, this._transactions);\n    }\n\n    this._history.unshift(item);\n\n    this._history.splice(10, this._history.length - 10);\n  }\n\n  async focusAvailable() {\n    for (const i of this._history) {\n      if (await i.focusAvailable()) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  async resetFocus() {\n    for (const i of this._history) {\n      if (await i.resetFocus()) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\nclass CrossOriginTransaction {\n  constructor(tabster, getOwner, knownTargets, value, timeout, sentTo, targetId, sendUp) {\n    this._inProgress = {};\n    this._isDone = false;\n    this._isSelfResponding = false;\n    this._sentCount = 0;\n    this.tabster = tabster;\n    this.owner = getOwner;\n    this.ownerId = getWindowUId(getOwner());\n    this.id = getUId(getOwner());\n    this.beginData = value;\n    this._knownTargets = knownTargets;\n    this._sentTo = sentTo || {\n      [this.ownerId]: true\n    };\n    this.targetId = targetId;\n    this.sendUp = sendUp;\n    this.timeout = timeout;\n    this._promise = new (getPromise(getOwner))((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  getTargets(knownTargets) {\n    return this.targetId === _targetIdUp ? this.sendUp ? {\n      [_targetIdUp]: {\n        send: this.sendUp\n      }\n    } : null : this.targetId ? knownTargets[this.targetId] ? {\n      [this.targetId]: {\n        send: knownTargets[this.targetId].send\n      }\n    } : null : Object.keys(knownTargets).length === 0 && this.sendUp ? {\n      [_targetIdUp]: {\n        send: this.sendUp\n      }\n    } : Object.keys(knownTargets).length > 0 ? knownTargets : null;\n  }\n\n  begin(selfResponse) {\n    const targets = this.getTargets(this._knownTargets);\n    const sentTo = { ...this._sentTo\n    };\n\n    if (targets) {\n      for (const id of Object.keys(targets)) {\n        sentTo[id] = true;\n      }\n    }\n\n    const data = {\n      transaction: this.id,\n      type: this.type,\n      isResponse: false,\n      timestamp: Date.now(),\n      owner: this.ownerId,\n      sentto: sentTo,\n      timeout: this.timeout,\n      beginData: this.beginData\n    };\n\n    if (this.targetId) {\n      data.target = this.targetId;\n    }\n\n    if (selfResponse) {\n      this._isSelfResponding = true;\n      selfResponse(data).then(value => {\n        this._isSelfResponding = false;\n\n        if (value !== undefined) {\n          if (!this.endData) {\n            this.endData = value;\n          }\n        }\n\n        if (this.endData || this._sentCount === 0) {\n          this.end();\n        }\n      });\n    }\n\n    if (targets) {\n      for (const id of Object.keys(targets)) {\n        if (!(id in this._sentTo)) {\n          this._send(targets[id].send, id, data);\n        }\n      }\n    }\n\n    if (this._sentCount === 0 && !this._isSelfResponding) {\n      this.end();\n    }\n\n    return this._promise;\n  }\n\n  _send(send, targetId, data) {\n    if (this._inProgress[targetId] === undefined) {\n      this._inProgress[targetId] = true;\n      this._sentCount++;\n      send(data);\n    }\n  }\n\n  end(error) {\n    if (this._isDone) {\n      return;\n    }\n\n    this._isDone = true;\n\n    if (this.endData === undefined && error) {\n      if (this._reject) {\n        this._reject(error);\n      }\n    } else if (this._resolve) {\n      this._resolve(this.endData);\n    }\n  }\n\n  onResponse(data) {\n    const endData = data.endData;\n\n    if (endData !== undefined && !this.endData) {\n      this.endData = endData;\n    }\n\n    const inProgressId = data.target === _targetIdUp ? _targetIdUp : data.owner;\n\n    if (this._inProgress[inProgressId]) {\n      this._inProgress[inProgressId] = false;\n      this._sentCount--;\n\n      if (this.endData || this._sentCount === 0 && !this._isSelfResponding) {\n        this.end();\n      }\n    }\n  }\n\n}\n\nclass BootstrapTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.Bootstrap;\n  }\n\n  static shouldForward() {\n    return false;\n  }\n\n  static async makeResponse(tabster) {\n    return {\n      isNavigatingWithKeyboard: tabster.keyboardNavigation.isNavigatingWithKeyboard()\n    };\n  }\n\n}\n\nclass FocusElementTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.FocusElement;\n  }\n\n  static shouldSelfRespond() {\n    return true;\n  }\n\n  static shouldForward(tabster, data, getOwner) {\n    const el = GetElementTransaction.findElement(tabster, getOwner, data.beginData);\n    return !el || !tabster.focusable.isFocusable(el);\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerId, transactions, forwardResult) {\n    const el = GetElementTransaction.findElement(tabster, getOwner, data.beginData);\n    return !!el && tabster.focusedElement.focus(el, true) || !!(await forwardResult);\n  }\n\n}\n\nconst CrossOriginStates = {\n  Focused: 1,\n  Blurred: 2,\n  Observed: 3,\n  DeadWindow: 4,\n  KeyboardNavigation: 5,\n  Outline: 6\n};\n\nclass StateTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.State;\n  }\n\n  static shouldSelfRespond(tabster, data) {\n    return data.state !== CrossOriginStates.DeadWindow && data.state !== CrossOriginStates.KeyboardNavigation;\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerId, transactions, forwardResult, isSelfResponse) {\n    const timestamp = data.timestamp;\n    const beginData = data.beginData;\n\n    if (timestamp && beginData) {\n      switch (beginData.state) {\n        case CrossOriginStates.Focused:\n          return StateTransaction._makeFocusedResponse(tabster, timestamp, beginData, transactions, isSelfResponse);\n\n        case CrossOriginStates.Blurred:\n          return StateTransaction._makeBlurredResponse(tabster, timestamp, beginData, transactions.ctx);\n\n        case CrossOriginStates.Observed:\n          return StateTransaction._makeObservedResponse(tabster, beginData);\n\n        case CrossOriginStates.DeadWindow:\n          return StateTransaction._makeDeadWindowResponse(tabster, beginData, transactions, forwardResult);\n\n        case CrossOriginStates.KeyboardNavigation:\n          return StateTransaction._makeKeyboardNavigationResponse(tabster, transactions.ctx, beginData.isNavigatingWithKeyboard);\n\n        case CrossOriginStates.Outline:\n          return StateTransaction._makeOutlineResponse(tabster, transactions.ctx, beginData.outline);\n      }\n    }\n\n    return true;\n  }\n\n  static createElement(tabster, beginData) {\n    return beginData.uid ? new CrossOriginElement(tabster, beginData.uid, beginData.ownerUId, beginData.id, beginData.rootUId, beginData.observedName, beginData.observedDetails) : null;\n  }\n\n  static async _makeFocusedResponse(tabster, timestamp, beginData, transactions, isSelfResponse) {\n    const element = StateTransaction.createElement(tabster, beginData);\n\n    if (beginData && beginData.ownerUId && element) {\n      transactions.ctx.focusOwner = beginData.ownerUId;\n      transactions.ctx.focusOwnerTimestamp = timestamp;\n\n      if (!isSelfResponse && beginData.rootUId && beginData.deloserUId) {\n        const deloserAPI = tabster.deloser;\n\n        if (deloserAPI) {\n          const history = DeloserAPI.getHistory(deloserAPI);\n          const deloser = {\n            ownerUId: beginData.ownerUId,\n            deloserUId: beginData.deloserUId,\n            rootUId: beginData.rootUId\n          };\n          const historyItem = history.make(beginData.rootUId, () => new CrossOriginDeloserHistoryByRoot(tabster, deloser.rootUId, transactions));\n          historyItem.unshift(deloser);\n        }\n      }\n\n      CrossOriginFocusedElementState.setVal( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.crossOrigin.focusedElement, element, {\n        isFocusedProgrammatically: beginData.isFocusedProgrammatically\n      });\n    }\n\n    return true;\n  }\n\n  static async _makeBlurredResponse(tabster, timestamp, beginData, context) {\n    if (beginData && (beginData.ownerUId === context.focusOwner || beginData.force) && (!context.focusOwnerTimestamp || context.focusOwnerTimestamp < timestamp)) {\n      CrossOriginFocusedElementState.setVal( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.crossOrigin.focusedElement, undefined, {});\n    }\n\n    return true;\n  }\n\n  static async _makeObservedResponse(tabster, beginData) {\n    const name = beginData.observedName;\n    const element = StateTransaction.createElement(tabster, beginData);\n\n    if (name && element) {\n      CrossOriginObservedElementState.trigger( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.crossOrigin.observedElement, element, {\n        names: [name],\n        details: beginData.observedDetails\n      });\n    }\n\n    return true;\n  }\n\n  static async _makeDeadWindowResponse(tabster, beginData, transactions, forwardResult) {\n    const deadUId = beginData && beginData.ownerUId;\n\n    if (deadUId) {\n      transactions.removeTarget(deadUId);\n    }\n\n    return forwardResult.then(() => {\n      if (deadUId === transactions.ctx.focusOwner) {\n        const deloserAPI = tabster.deloser;\n\n        if (deloserAPI) {\n          DeloserAPI.forceRestoreFocus(deloserAPI);\n        }\n      }\n\n      return true;\n    });\n  }\n\n  static async _makeKeyboardNavigationResponse(tabster, context, isNavigatingWithKeyboard) {\n    if (isNavigatingWithKeyboard !== undefined && tabster.keyboardNavigation.isNavigatingWithKeyboard() !== isNavigatingWithKeyboard) {\n      context.ignoreKeyboardNavigationStateUpdate = true;\n      tabster.keyboardNavigation.setNavigatingWithKeyboard(isNavigatingWithKeyboard);\n      context.ignoreKeyboardNavigationStateUpdate = false;\n    }\n\n    return true;\n  }\n\n  static async _makeOutlineResponse(tabster, context, props) {\n    if (context.origOutlineSetup) {\n      context.origOutlineSetup.call( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.outline, props);\n    }\n\n    return true;\n  }\n\n}\n\nclass GetElementTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.GetElement;\n  }\n\n  static shouldSelfRespond() {\n    return true;\n  }\n\n  static findElement(tabster, getOwner, data) {\n    let element;\n\n    if (data && (!data.ownerId || data.ownerId === getWindowUId(getOwner()))) {\n      if (data.id) {\n        element = dom.getElementById(getOwner().document, data.id);\n\n        if (element && data.rootId) {\n          const ctx = RootAPI.getTabsterContext(tabster, element);\n\n          if (!ctx || ctx.root.uid !== data.rootId) {\n            return null;\n          }\n        }\n      } else if (data.uid) {\n        const ref = getInstanceContext(getOwner).elementByUId[data.uid];\n        element = ref && ref.get();\n      } else if (data.observedName) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        element = tabster.observedElement.getElement(data.observedName, data.accessibility);\n      }\n    }\n\n    return element || null;\n  }\n\n  static getElementData(tabster, element, getOwner, context, ownerUId) {\n    const deloser = DeloserAPI.getDeloser(tabster, element);\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n    const tabsterOnElement = getTabsterOnElement(tabster, element);\n    const observed = tabsterOnElement && tabsterOnElement.observed;\n    return {\n      uid: getElementUId(getOwner, element),\n      ownerUId,\n      id: element.id || undefined,\n      rootUId: ctx ? ctx.root.uid : undefined,\n      deloserUId: deloser ? getDeloserUID(getOwner, context, deloser) : undefined,\n      observedName: observed && observed.names && observed.names[0],\n      observedDetails: observed && observed.details\n    };\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerUId, transactions, forwardResult) {\n    const beginData = data.beginData;\n    let element;\n    let dataOut;\n\n    if (beginData === undefined) {\n      element = tabster.focusedElement.getFocusedElement();\n    } else if (beginData) {\n      element = GetElementTransaction.findElement(tabster, getOwner, beginData) || undefined;\n    }\n\n    if (!element && beginData) {\n      const name = beginData.observedName;\n      const timeout = data.timeout;\n      const accessibility = beginData.accessibility;\n\n      if (name && timeout) {\n        const e = await new (getPromise(getOwner))(resolve => {\n          let isWaitElementResolved = false;\n          let isForwardResolved = false;\n          let isResolved = false; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n          tabster.observedElement.waitElement(name, timeout, accessibility).result.then(value => {\n            isWaitElementResolved = true;\n\n            if (!isResolved && (value || isForwardResolved)) {\n              isResolved = true;\n              resolve({\n                element: value\n              });\n            }\n          });\n          forwardResult.then(value => {\n            isForwardResolved = true;\n\n            if (!isResolved && (value || isWaitElementResolved)) {\n              isResolved = true;\n              resolve({\n                crossOrigin: value\n              });\n            }\n          });\n        });\n\n        if (e.element) {\n          element = e.element;\n        } else if (e.crossOrigin) {\n          dataOut = e.crossOrigin;\n        }\n      }\n    }\n\n    return element ? GetElementTransaction.getElementData(tabster, element, getOwner, transactions.ctx, ownerUId) : dataOut;\n  }\n\n}\n\nclass RestoreFocusInDeloserTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.RestoreFocusInDeloser;\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerId, transactions, forwardResult) {\n    const forwardRet = await forwardResult;\n    const begin = !forwardRet && data.beginData;\n    const uid = begin && begin.deloserUId;\n    const deloser = uid && transactions.ctx.deloserByUId[uid];\n    const deloserAPI = tabster.deloser;\n\n    if (begin && deloser && deloserAPI) {\n      const history = DeloserAPI.getHistory(deloserAPI);\n      return begin.reset ? history.resetFocus(deloser) : history.focusAvailable(deloser);\n    }\n\n    return !!forwardRet;\n  }\n\n}\n\nclass PingTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.Ping;\n  }\n\n  static shouldForward() {\n    return false;\n  }\n\n  static async makeResponse() {\n    return true;\n  }\n\n}\n\nclass CrossOriginTransactions {\n  constructor(tabster, getOwner, context) {\n    this._knownTargets = {};\n    this._transactions = {};\n    this._isDefaultSendUp = false;\n    this.isSetUp = false;\n\n    this._onMessage = e => {\n      if (e.data.owner === this._ownerUId || !this._tabster) {\n        return;\n      } // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\n      const data = e.data;\n      let transactionId;\n\n      if (!data || !(transactionId = data.transaction) || !data.type || !data.timestamp || !data.owner || !data.sentto) {\n        return;\n      }\n\n      let knownTarget = this._knownTargets[data.owner];\n\n      if (!knownTarget && e.send && data.owner !== this._ownerUId) {\n        knownTarget = this._knownTargets[data.owner] = {\n          send: e.send\n        };\n      }\n\n      if (knownTarget) {\n        knownTarget.last = Date.now();\n      }\n\n      if (data.isResponse) {\n        const t = this._transactions[transactionId];\n\n        if (t && t.transaction && t.transaction.type === data.type) {\n          t.transaction.onResponse(data);\n        }\n      } else {\n        const Transaction = this._getTransactionClass(data.type);\n\n        const forwardResult = this.forwardTransaction(data);\n\n        if (Transaction && e.send) {\n          Transaction.makeResponse(this._tabster, data, this._owner, this._ownerUId, this, forwardResult, false).then(r => {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const response = {\n              transaction: data.transaction,\n              type: data.type,\n              isResponse: true,\n              timestamp: Date.now(),\n              owner: this._ownerUId,\n              timeout: data.timeout,\n              sentto: {},\n              target: data.target === _targetIdUp ? _targetIdUp : data.owner,\n              endData: r\n            };\n            e.send(response);\n          });\n        }\n      }\n    };\n\n    this._onPageHide = () => {\n      this._dead();\n    };\n\n    this._onBrowserMessage = e => {\n      if (e.source === this._owner()) {\n        return;\n      } // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\n      const send = data => {\n        if (e.source && e.source.postMessage) {\n          // eslint-disable-next-line @typescript-eslint/ban-types\n          e.source.postMessage(JSON.stringify(data), \"*\");\n        }\n      };\n\n      try {\n        this._onMessage({\n          data: JSON.parse(e.data),\n          send\n        });\n      } catch (e) {\n        /* Ignore */\n      }\n    };\n\n    this._tabster = tabster;\n    this._owner = getOwner;\n    this._ownerUId = getWindowUId(getOwner());\n    this.ctx = context;\n  }\n\n  setup(sendUp) {\n    if (this.isSetUp) {\n      if (process.env.NODE_ENV === 'development') {\n        console.error(\"CrossOrigin is already set up.\");\n      }\n    } else {\n      this.isSetUp = true;\n      this.setSendUp(sendUp);\n\n      this._owner().addEventListener(\"pagehide\", this._onPageHide);\n\n      this._ping();\n    }\n\n    return this._onMessage;\n  }\n\n  setSendUp(sendUp) {\n    if (!this.isSetUp) {\n      throw new Error(\"CrossOrigin is not set up.\");\n    }\n\n    this.sendUp = sendUp || undefined;\n\n    const owner = this._owner();\n\n    if (sendUp === undefined) {\n      if (!this._isDefaultSendUp) {\n        if (owner.document) {\n          this._isDefaultSendUp = true;\n\n          if (owner.parent && owner.parent !== owner && owner.parent.postMessage) {\n            this.sendUp = ( // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data) => {\n              owner.parent.postMessage(JSON.stringify(data), \"*\");\n            };\n          }\n\n          owner.addEventListener(\"message\", this._onBrowserMessage);\n        }\n      }\n    } else if (this._isDefaultSendUp) {\n      owner.removeEventListener(\"message\", this._onBrowserMessage);\n      this._isDefaultSendUp = false;\n    }\n\n    return this._onMessage;\n  }\n\n  async dispose() {\n    const owner = this._owner();\n\n    if (this._pingTimer) {\n      owner.clearTimeout(this._pingTimer);\n      this._pingTimer = undefined;\n    }\n\n    owner.removeEventListener(\"message\", this._onBrowserMessage);\n    owner.removeEventListener(\"pagehide\", this._onPageHide);\n    await this._dead();\n    delete this._deadPromise;\n\n    for (const id of Object.keys(this._transactions)) {\n      const t = this._transactions[id];\n\n      if (t.timer) {\n        owner.clearTimeout(t.timer);\n        delete t.timer;\n      }\n\n      t.transaction.end();\n    }\n\n    this._knownTargets = {};\n    delete this.sendUp;\n  }\n\n  beginTransaction(Transaction, value, timeout, sentTo, targetId, withReject) {\n    if (!this._owner) {\n      return getPromise(this._owner).reject();\n    }\n\n    const transaction = new Transaction(this._tabster, this._owner, this._knownTargets, value, timeout, sentTo, targetId, this.sendUp);\n    let selfResponse;\n\n    if (Transaction.shouldSelfRespond && Transaction.shouldSelfRespond(this._tabster, value, this._owner, this._ownerUId)) {\n      selfResponse = data => {\n        return Transaction.makeResponse(this._tabster, data, this._owner, this._ownerUId, this, getPromise(this._owner).resolve(undefined), true);\n      };\n    }\n\n    return this._beginTransaction(transaction, timeout, selfResponse, withReject);\n  }\n\n  removeTarget(uid) {\n    delete this._knownTargets[uid];\n  }\n\n  _beginTransaction(transaction, timeout, selfResponse, withReject) {\n    const owner = this._owner();\n\n    const wrapper = {\n      transaction,\n      timer: owner.setTimeout(() => {\n        delete wrapper.timer;\n        transaction.end(\"Cross origin transaction timed out.\");\n      }, _transactionTimeout + (timeout || 0))\n    };\n    this._transactions[transaction.id] = wrapper;\n    const ret = transaction.begin(selfResponse);\n    ret.catch(() => {\n      /**/\n    }).finally(() => {\n      if (wrapper.timer) {\n        owner.clearTimeout(wrapper.timer);\n      }\n\n      delete this._transactions[transaction.id];\n    });\n    return ret.then(value => value, withReject ? undefined : () => undefined);\n  }\n\n  forwardTransaction( // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  data // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ) {\n    const owner = this._owner;\n    let targetId = data.target;\n\n    if (targetId === this._ownerUId) {\n      return getPromise(owner).resolve();\n    }\n\n    const Transaction = this._getTransactionClass(data.type);\n\n    if (Transaction) {\n      if (Transaction.shouldForward === undefined || Transaction.shouldForward(this._tabster, data, owner, this._ownerUId)) {\n        const sentTo = data.sentto;\n\n        if (targetId === _targetIdUp) {\n          targetId = undefined;\n          sentTo[this._ownerUId] = true;\n        }\n\n        delete sentTo[_targetIdUp];\n        return this._beginTransaction(new Transaction(this._tabster, owner, this._knownTargets, data.beginData, data.timeout, sentTo, targetId, this.sendUp), data.timeout);\n      } else {\n        return getPromise(owner).resolve();\n      }\n    }\n\n    return getPromise(owner).reject(`Unknown transaction type ${data.type}`);\n  }\n\n  _getTransactionClass(type // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ) {\n    switch (type) {\n      case CrossOriginTransactionTypes.Bootstrap:\n        return BootstrapTransaction;\n\n      case CrossOriginTransactionTypes.FocusElement:\n        return FocusElementTransaction;\n\n      case CrossOriginTransactionTypes.State:\n        return StateTransaction;\n\n      case CrossOriginTransactionTypes.GetElement:\n        return GetElementTransaction;\n\n      case CrossOriginTransactionTypes.RestoreFocusInDeloser:\n        return RestoreFocusInDeloserTransaction;\n\n      case CrossOriginTransactionTypes.Ping:\n        return PingTransaction;\n\n      default:\n        return null;\n    }\n  }\n\n  async _dead() {\n    if (!this._deadPromise && this.ctx.focusOwner === this._ownerUId) {\n      this._deadPromise = this.beginTransaction(StateTransaction, {\n        ownerUId: this._ownerUId,\n        state: CrossOriginStates.DeadWindow\n      });\n    }\n\n    if (this._deadPromise) {\n      await this._deadPromise;\n    }\n  }\n\n  async _ping() {\n    if (this._pingTimer) {\n      return;\n    }\n\n    let deadWindows;\n    const now = Date.now();\n    const targets = Object.keys(this._knownTargets).filter(uid => now - (this._knownTargets[uid].last || 0) > _pingTimeout);\n\n    if (this.sendUp) {\n      targets.push(_targetIdUp);\n    }\n\n    if (targets.length) {\n      await getPromise(this._owner).all(targets.map(uid => this.beginTransaction(PingTransaction, undefined, undefined, undefined, uid, true).then(() => true, () => {\n        if (uid !== _targetIdUp) {\n          if (!deadWindows) {\n            deadWindows = {};\n          }\n\n          deadWindows[uid] = true;\n          delete this._knownTargets[uid];\n        }\n\n        return false;\n      })));\n    }\n\n    if (deadWindows) {\n      const focused = await this.beginTransaction(GetElementTransaction, undefined);\n\n      if (!focused && this.ctx.focusOwner && this.ctx.focusOwner in deadWindows) {\n        await this.beginTransaction(StateTransaction, {\n          ownerUId: this._ownerUId,\n          state: CrossOriginStates.Blurred,\n          force: true\n        });\n        const deloserAPI = this._tabster.deloser;\n\n        if (deloserAPI) {\n          DeloserAPI.forceRestoreFocus(deloserAPI);\n        }\n      }\n    }\n\n    this._pingTimer = this._owner().setTimeout(() => {\n      this._pingTimer = undefined;\n\n      this._ping();\n    }, _pingTimeout);\n  }\n\n}\n\nclass CrossOriginElement {\n  constructor(tabster, uid, ownerId, id, rootId, observedName, observedDetails) {\n    this._tabster = tabster;\n    this.uid = uid;\n    this.ownerId = ownerId;\n    this.id = id;\n    this.rootId = rootId;\n    this.observedName = observedName;\n    this.observedDetails = observedDetails;\n  }\n\n  focus(noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this._tabster.crossOrigin.focusedElement.focus(this, noFocusedProgrammaticallyFlag, noAccessibleCheck);\n  }\n\n}\nclass CrossOriginFocusedElementState extends Subscribable {\n  constructor(transactions) {\n    super();\n    this._transactions = transactions;\n  }\n\n  async focus(element, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    return this._focus({\n      uid: element.uid,\n      id: element.id,\n      rootId: element.rootId,\n      ownerId: element.ownerId,\n      observedName: element.observedName\n    }, noFocusedProgrammaticallyFlag, noAccessibleCheck);\n  }\n\n  async focusById(elementId, rootId, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    return this._focus({\n      id: elementId,\n      rootId\n    }, noFocusedProgrammaticallyFlag, noAccessibleCheck);\n  }\n\n  async focusByObservedName(observedName, timeout, rootId, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    return this._focus({\n      observedName,\n      rootId\n    }, noFocusedProgrammaticallyFlag, noAccessibleCheck, timeout);\n  }\n\n  async _focus(elementData, noFocusedProgrammaticallyFlag, noAccessibleCheck, timeout) {\n    return this._transactions.beginTransaction(FocusElementTransaction, { ...elementData,\n      noFocusedProgrammaticallyFlag,\n      noAccessibleCheck\n    }, timeout).then(value => !!value);\n  }\n\n  static setVal(instance, val, details) {\n    instance.setVal(val, details);\n  }\n\n}\nclass CrossOriginObservedElementState extends Subscribable {\n  constructor(tabster, transactions) {\n    super();\n    this._lastRequestFocusId = 0;\n    this._tabster = tabster;\n    this._transactions = transactions;\n  }\n\n  async getElement(observedName, accessibility) {\n    return this.waitElement(observedName, 0, accessibility);\n  }\n\n  async waitElement(observedName, timeout, accessibility) {\n    return this._transactions.beginTransaction(GetElementTransaction, {\n      observedName,\n      accessibility\n    }, timeout).then(value => value ? StateTransaction.createElement(this._tabster, value) : null);\n  }\n\n  async requestFocus(observedName, timeout) {\n    const requestId = ++this._lastRequestFocusId;\n    return this.waitElement(observedName, timeout, ObservedElementAccesibilities.Focusable).then(element => this._lastRequestFocusId === requestId && element ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    this._tabster.crossOrigin.focusedElement.focus(element, true) : false);\n  }\n\n  static trigger(instance, element, details) {\n    instance.trigger(element, details);\n  }\n\n}\nclass CrossOriginAPI {\n  constructor(tabster) {\n    this._init = () => {\n      const tabster = this._tabster;\n      tabster.keyboardNavigation.subscribe(this._onKeyboardNavigationStateChanged);\n      tabster.focusedElement.subscribe(this._onFocus); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n      tabster.observedElement.subscribe(this._onObserved);\n\n      if (!this._ctx.origOutlineSetup) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        this._ctx.origOutlineSetup = tabster.outline.setup; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n        tabster.outline.setup = this._outlineSetup;\n      }\n\n      this._transactions.beginTransaction(BootstrapTransaction, undefined, undefined, undefined, _targetIdUp).then(data => {\n        if (data && this._tabster.keyboardNavigation.isNavigatingWithKeyboard() !== data.isNavigatingWithKeyboard) {\n          this._ctx.ignoreKeyboardNavigationStateUpdate = true;\n\n          this._tabster.keyboardNavigation.setNavigatingWithKeyboard(data.isNavigatingWithKeyboard);\n\n          this._ctx.ignoreKeyboardNavigationStateUpdate = false;\n        }\n      });\n    };\n\n    this._onKeyboardNavigationStateChanged = value => {\n      if (!this._ctx.ignoreKeyboardNavigationStateUpdate) {\n        this._transactions.beginTransaction(StateTransaction, {\n          state: CrossOriginStates.KeyboardNavigation,\n          ownerUId: getWindowUId(this._win()),\n          isNavigatingWithKeyboard: value\n        });\n      }\n    };\n\n    this._onFocus = element => {\n      const win = this._win();\n\n      const ownerUId = getWindowUId(win);\n\n      if (this._blurTimer) {\n        win.clearTimeout(this._blurTimer);\n        this._blurTimer = undefined;\n      }\n\n      if (element) {\n        this._transactions.beginTransaction(StateTransaction, { ...GetElementTransaction.getElementData(this._tabster, element, this._win, this._ctx, ownerUId),\n          state: CrossOriginStates.Focused\n        });\n      } else {\n        this._blurTimer = win.setTimeout(() => {\n          this._blurTimer = undefined;\n\n          if (this._ctx.focusOwner && this._ctx.focusOwner === ownerUId) {\n            this._transactions.beginTransaction(GetElementTransaction, undefined).then(value => {\n              if (!value && this._ctx.focusOwner === ownerUId) {\n                this._transactions.beginTransaction(StateTransaction, {\n                  ownerUId,\n                  state: CrossOriginStates.Blurred,\n                  force: false\n                });\n              }\n            });\n          }\n        }, 0);\n      }\n    };\n\n    this._onObserved = (element, details) => {\n      var _a;\n\n      const d = GetElementTransaction.getElementData(this._tabster, element, this._win, this._ctx, getWindowUId(this._win()));\n      d.state = CrossOriginStates.Observed;\n      d.observedName = (_a = details.names) === null || _a === void 0 ? void 0 : _a[0];\n      d.observedDetails = details.details;\n\n      this._transactions.beginTransaction(StateTransaction, d);\n    };\n\n    this._outlineSetup = props => {\n      this._transactions.beginTransaction(StateTransaction, {\n        state: CrossOriginStates.Outline,\n        ownerUId: getWindowUId(this._win()),\n        outline: props\n      });\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._ctx = {\n      ignoreKeyboardNavigationStateUpdate: false,\n      deloserByUId: {}\n    };\n    this._transactions = new CrossOriginTransactions(tabster, this._win, this._ctx);\n    this.focusedElement = new CrossOriginFocusedElementState(this._transactions);\n    this.observedElement = new CrossOriginObservedElementState(tabster, this._transactions);\n  }\n\n  setup(sendUp) {\n    if (this.isSetUp()) {\n      return this._transactions.setSendUp(sendUp);\n    } else {\n      this._tabster.queueInit(this._init);\n\n      return this._transactions.setup(sendUp);\n    }\n  }\n\n  isSetUp() {\n    return this._transactions.isSetUp;\n  }\n\n  dispose() {\n    var _a;\n\n    const tabster = this._tabster;\n    tabster.keyboardNavigation.unsubscribe(this._onKeyboardNavigationStateChanged);\n    tabster.focusedElement.unsubscribe(this._onFocus);\n    (_a = tabster.observedElement) === null || _a === void 0 ? void 0 : _a.unsubscribe(this._onObserved);\n\n    this._transactions.dispose();\n\n    this.focusedElement.dispose();\n    this.observedElement.dispose();\n    this._ctx.deloserByUId = {};\n  }\n\n}\n\nfunction getDeloserUID(getWindow, context, deloser) {\n  const deloserElement = deloser.getElement();\n\n  if (deloserElement) {\n    const uid = getElementUId(getWindow, deloserElement);\n\n    if (!context.deloserByUId[uid]) {\n      context.deloserByUId[uid] = deloser;\n    }\n\n    return uid;\n  }\n\n  return undefined;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass FocusableAPI {\n  constructor(tabster) {\n    this._tabster = tabster;\n  }\n\n  dispose() {\n    /**/\n  }\n\n  getProps(element) {\n    const tabsterOnElement = getTabsterOnElement(this._tabster, element);\n    return tabsterOnElement && tabsterOnElement.focusable || {};\n  }\n\n  isFocusable(el, includeProgrammaticallyFocusable, noVisibleCheck, noAccessibleCheck) {\n    if (matchesSelector(el, FocusableSelector) && (includeProgrammaticallyFocusable || el.tabIndex !== -1)) {\n      return (noVisibleCheck || this.isVisible(el)) && (noAccessibleCheck || this.isAccessible(el));\n    }\n\n    return false;\n  }\n\n  isVisible(el) {\n    if (!el.ownerDocument || el.nodeType !== Node.ELEMENT_NODE) {\n      return false;\n    }\n\n    if (el.offsetParent === null && el.ownerDocument.body !== el) {\n      return false;\n    }\n\n    const win = el.ownerDocument.defaultView;\n\n    if (!win) {\n      return false;\n    }\n\n    const rect = el.ownerDocument.body.getBoundingClientRect();\n\n    if (rect.width === 0 && rect.height === 0) {\n      // This might happen, for example, if our <body> is in hidden <iframe>.\n      return false;\n    }\n\n    const computedStyle = win.getComputedStyle(el);\n\n    if (computedStyle.visibility === \"hidden\") {\n      return false;\n    }\n\n    return true;\n  }\n\n  isAccessible(el) {\n    var _a;\n\n    for (let e = el; e; e = dom.getParentElement(e)) {\n      const tabsterOnElement = getTabsterOnElement(this._tabster, e);\n\n      if (this._isHidden(e)) {\n        return false;\n      }\n\n      const ignoreDisabled = (_a = tabsterOnElement === null || tabsterOnElement === void 0 ? void 0 : tabsterOnElement.focusable) === null || _a === void 0 ? void 0 : _a.ignoreAriaDisabled;\n\n      if (!ignoreDisabled && this._isDisabled(e)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  _isDisabled(el) {\n    return el.hasAttribute(\"disabled\");\n  }\n\n  _isHidden(el) {\n    var _a;\n\n    const attrVal = el.getAttribute(\"aria-hidden\");\n\n    if (attrVal && attrVal.toLowerCase() === \"true\") {\n      if (!((_a = this._tabster.modalizer) === null || _a === void 0 ? void 0 : _a.isAugmented(el))) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  findFirst(options, out) {\n    return this.findElement({ ...options\n    }, out);\n  }\n\n  findLast(options, out) {\n    return this.findElement({\n      isBackward: true,\n      ...options\n    }, out);\n  }\n\n  findNext(options, out) {\n    return this.findElement({ ...options\n    }, out);\n  }\n\n  findPrev(options, out) {\n    return this.findElement({ ...options,\n      isBackward: true\n    }, out);\n  }\n\n  findDefault(options, out) {\n    return this.findElement({ ...options,\n      acceptCondition: el => this.isFocusable(el, options.includeProgrammaticallyFocusable) && !!this.getProps(el).isDefault\n    }, out) || null;\n  }\n\n  findAll(options) {\n    return this._findElements(true, options) || [];\n  }\n\n  findElement(options, out) {\n    const found = this._findElements(false, options, out);\n\n    return found ? found[0] : found;\n  }\n\n  _findElements(findAll, options, out) {\n    var _a, _b, _c;\n\n    const {\n      container,\n      currentElement = null,\n      includeProgrammaticallyFocusable,\n      useActiveModalizer,\n      ignoreAccessibility,\n      modalizerId,\n      isBackward,\n      onElement\n    } = options;\n\n    if (!out) {\n      out = {};\n    }\n\n    const elements = [];\n    let {\n      acceptCondition\n    } = options;\n    const hasCustomCondition = !!acceptCondition;\n\n    if (!container) {\n      return null;\n    }\n\n    if (!acceptCondition) {\n      acceptCondition = el => this.isFocusable(el, includeProgrammaticallyFocusable, false, ignoreAccessibility);\n    }\n\n    const acceptElementState = {\n      container,\n      modalizerUserId: modalizerId === undefined && useActiveModalizer ? (_a = this._tabster.modalizer) === null || _a === void 0 ? void 0 : _a.activeId : modalizerId || ((_c = (_b = RootAPI.getTabsterContext(this._tabster, container)) === null || _b === void 0 ? void 0 : _b.modalizer) === null || _c === void 0 ? void 0 : _c.userId),\n      from: currentElement || container,\n      isBackward,\n      acceptCondition,\n      hasCustomCondition,\n      includeProgrammaticallyFocusable,\n      ignoreAccessibility,\n      cachedGrouppers: {}\n    };\n    const walker = createElementTreeWalker(container.ownerDocument, container, node => this._acceptElement(node, acceptElementState));\n\n    if (!walker) {\n      return null;\n    }\n\n    const prepareForNextElement = shouldContinueIfNotFound => {\n      var _a, _b;\n\n      const foundElement = (_a = acceptElementState.foundElement) !== null && _a !== void 0 ? _a : acceptElementState.foundBackward;\n\n      if (foundElement) {\n        elements.push(foundElement);\n      }\n\n      if (findAll) {\n        if (foundElement) {\n          acceptElementState.found = false;\n          delete acceptElementState.foundElement;\n          delete acceptElementState.foundBackward;\n          delete acceptElementState.fromCtx;\n          acceptElementState.from = foundElement;\n\n          if (onElement && !onElement(foundElement)) {\n            return false;\n          }\n        }\n\n        return !!(foundElement || shouldContinueIfNotFound);\n      } else {\n        if (foundElement && out) {\n          out.uncontrolled = (_b = RootAPI.getTabsterContext(this._tabster, foundElement)) === null || _b === void 0 ? void 0 : _b.uncontrolled;\n        }\n\n        return !!(shouldContinueIfNotFound && !foundElement);\n      }\n    };\n\n    if (!currentElement) {\n      out.outOfDOMOrder = true;\n    }\n\n    if (currentElement && dom.nodeContains(container, currentElement)) {\n      walker.currentNode = currentElement;\n    } else if (isBackward) {\n      const lastChild = getLastChild$2(container);\n\n      if (!lastChild) {\n        return null;\n      }\n\n      if (this._acceptElement(lastChild, acceptElementState) === NodeFilter.FILTER_ACCEPT && !prepareForNextElement(true)) {\n        if (acceptElementState.skippedFocusable) {\n          out.outOfDOMOrder = true;\n        }\n\n        return elements;\n      }\n\n      walker.currentNode = lastChild;\n    }\n\n    do {\n      if (isBackward) {\n        walker.previousNode();\n      } else {\n        walker.nextNode();\n      }\n    } while (prepareForNextElement());\n\n    if (acceptElementState.skippedFocusable) {\n      out.outOfDOMOrder = true;\n    }\n\n    return elements.length ? elements : null;\n  }\n\n  _acceptElement(element, state) {\n    var _a, _b, _c;\n\n    if (state.found) {\n      return NodeFilter.FILTER_ACCEPT;\n    }\n\n    const foundBackward = state.foundBackward;\n\n    if (foundBackward && (element === foundBackward || !dom.nodeContains(foundBackward, element))) {\n      state.found = true;\n      state.foundElement = foundBackward;\n      return NodeFilter.FILTER_ACCEPT;\n    }\n\n    const container = state.container;\n\n    if (element === container) {\n      return NodeFilter.FILTER_SKIP;\n    }\n\n    if (!dom.nodeContains(container, element)) {\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    if (element.__tabsterDummyContainer) {\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    if (dom.nodeContains(state.rejectElementsFrom, element)) {\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    const ctx = state.currentCtx = RootAPI.getTabsterContext(this._tabster, element); // Tabster is opt in, if it is not managed, don't try and get do anything special\n\n    if (!ctx) {\n      return NodeFilter.FILTER_SKIP;\n    }\n\n    if (shouldIgnoreFocus(element)) {\n      if (this.isFocusable(element, undefined, true, true)) {\n        state.skippedFocusable = true;\n      }\n\n      return NodeFilter.FILTER_SKIP;\n    } // We assume iframes are focusable because native tab behaviour would tab inside.\n    // But we do it only during the standard search when there is no custom accept\n    // element condition.\n\n\n    if (!state.hasCustomCondition && (element.tagName === \"IFRAME\" || element.tagName === \"WEBVIEW\")) {\n      if (((_a = ctx.modalizer) === null || _a === void 0 ? void 0 : _a.userId) === ((_b = this._tabster.modalizer) === null || _b === void 0 ? void 0 : _b.activeId)) {\n        state.found = true;\n        state.rejectElementsFrom = state.foundElement = element;\n        return NodeFilter.FILTER_ACCEPT;\n      } else {\n        return NodeFilter.FILTER_REJECT;\n      }\n    }\n\n    if (!state.ignoreAccessibility && !this.isAccessible(element)) {\n      if (this.isFocusable(element, false, true, true)) {\n        state.skippedFocusable = true;\n      }\n\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    let result;\n    let fromCtx = state.fromCtx;\n\n    if (!fromCtx) {\n      fromCtx = state.fromCtx = RootAPI.getTabsterContext(this._tabster, state.from);\n    }\n\n    const fromMover = fromCtx === null || fromCtx === void 0 ? void 0 : fromCtx.mover;\n    let groupper = ctx.groupper;\n    let mover = ctx.mover;\n    result = (_c = this._tabster.modalizer) === null || _c === void 0 ? void 0 : _c.acceptElement(element, state);\n\n    if (result !== undefined) {\n      state.skippedFocusable = true;\n    }\n\n    if (result === undefined && (groupper || mover || fromMover)) {\n      const groupperElement = groupper === null || groupper === void 0 ? void 0 : groupper.getElement();\n      const fromMoverElement = fromMover === null || fromMover === void 0 ? void 0 : fromMover.getElement();\n      let moverElement = mover === null || mover === void 0 ? void 0 : mover.getElement();\n\n      if (moverElement && dom.nodeContains(fromMoverElement, moverElement) && dom.nodeContains(container, fromMoverElement) && (!groupperElement || !mover || dom.nodeContains(fromMoverElement, groupperElement))) {\n        mover = fromMover;\n        moverElement = fromMoverElement;\n      }\n\n      if (groupperElement && (groupperElement === container || !dom.nodeContains(container, groupperElement))) {\n        groupper = undefined;\n      }\n\n      if (moverElement && !dom.nodeContains(container, moverElement)) {\n        mover = undefined;\n      }\n\n      if (groupper && mover) {\n        if (moverElement && groupperElement && !dom.nodeContains(groupperElement, moverElement)) {\n          mover = undefined;\n        } else {\n          groupper = undefined;\n        }\n      }\n\n      if (groupper) {\n        result = groupper.acceptElement(element, state);\n      }\n\n      if (mover) {\n        result = mover.acceptElement(element, state);\n      }\n    }\n\n    if (result === undefined) {\n      result = state.acceptCondition(element) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n\n      if (result === NodeFilter.FILTER_SKIP && this.isFocusable(element, false, true, true)) {\n        state.skippedFocusable = true;\n      }\n    }\n\n    if (result === NodeFilter.FILTER_ACCEPT && !state.found) {\n      if (state.isBackward) {\n        // When TreeWalker goes backwards, it visits the container first,\n        // then it goes inside. So, if the container is accepted, we remember it,\n        // but allowing the TreeWalker to check inside.\n        state.foundBackward = element;\n        result = NodeFilter.FILTER_SKIP;\n      } else {\n        state.found = true;\n        state.foundElement = element;\n      }\n    }\n\n    return result;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst Keys = {\n  Tab: 9,\n  Enter: 13,\n  Esc: 27,\n  Space: 32,\n  PageUp: 33,\n  PageDown: 34,\n  End: 35,\n  Home: 36,\n  Left: 37,\n  Up: 38,\n  Right: 39,\n  Down: 40\n};\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nfunction getUncontrolledCompletelyContainer(tabster, element) {\n  var _a;\n\n  const getParent = tabster.getParent;\n  let el = element;\n\n  do {\n    const uncontrolledOnElement = (_a = getTabsterOnElement(tabster, el)) === null || _a === void 0 ? void 0 : _a.uncontrolled;\n\n    if (uncontrolledOnElement && tabster.uncontrolled.isUncontrolledCompletely(el, !!uncontrolledOnElement.completely)) {\n      return el;\n    }\n\n    el = getParent(el);\n  } while (el);\n\n  return undefined;\n}\n\nclass FocusedElementState extends Subscribable {\n  constructor(tabster, getWindow) {\n    super();\n\n    this._init = () => {\n      const win = this._win();\n\n      const doc = win.document; // Add these event listeners as capture - we want Tabster to run before user event handlers\n\n      doc.addEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true);\n      doc.addEventListener(KEYBORG_FOCUSOUT, this._onFocusOut, true);\n      win.addEventListener(\"keydown\", this._onKeyDown, true);\n      const activeElement = dom.getActiveElement(doc);\n\n      if (activeElement && activeElement !== doc.body) {\n        this._setFocusedElement(activeElement);\n      }\n\n      this.subscribe(this._onChanged);\n    };\n\n    this._onFocusIn = e => {\n      const target = e.composedPath()[0];\n\n      if (target) {\n        this._setFocusedElement(target, e.detail.relatedTarget, e.detail.isFocusedProgrammatically);\n      }\n    };\n\n    this._onFocusOut = e => {\n      var _a;\n\n      this._setFocusedElement(undefined, (_a = e.detail) === null || _a === void 0 ? void 0 : _a.originalEvent.relatedTarget);\n    }; // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\n\n    this._validateFocusedElement = element => {// TODO: Make sure this is not needed anymore and write tests.\n    };\n\n    this._onKeyDown = event => {\n      if (event.keyCode !== Keys.Tab || event.ctrlKey) {\n        return;\n      }\n\n      const currentElement = this.getVal();\n\n      if (!currentElement || !currentElement.ownerDocument || currentElement.contentEditable === \"true\") {\n        return;\n      }\n\n      const tabster = this._tabster;\n      const controlTab = tabster.controlTab;\n      const ctx = RootAPI.getTabsterContext(tabster, currentElement);\n\n      if (!ctx || ctx.ignoreKeydown(event)) {\n        return;\n      }\n\n      const isBackward = event.shiftKey;\n      const next = FocusedElementState.findNextTabbable(tabster, ctx, undefined, currentElement, undefined, isBackward, true);\n      const rootElement = ctx.root.getElement();\n\n      if (!rootElement) {\n        return;\n      }\n\n      const nextElement = next === null || next === void 0 ? void 0 : next.element;\n      const uncontrolledCompletelyContainer = getUncontrolledCompletelyContainer(tabster, currentElement);\n\n      if (nextElement) {\n        const nextUncontrolled = next.uncontrolled;\n\n        if (ctx.uncontrolled || dom.nodeContains(nextUncontrolled, currentElement)) {\n          if (!next.outOfDOMOrder && nextUncontrolled === ctx.uncontrolled || uncontrolledCompletelyContainer && !dom.nodeContains(uncontrolledCompletelyContainer, nextElement)) {\n            // Nothing to do, everything will be done by the browser or something\n            // that controls the uncontrolled area.\n            return;\n          } // We are in uncontrolled area. We allow whatever controls it to move\n          // focus, but we add a phantom dummy to make sure the focus is moved\n          // to the correct place if the uncontrolled area allows default action.\n          // We only need that in the controlled mode, because in uncontrolled\n          // mode we have dummy inputs around everything that redirects focus.\n\n\n          DummyInputManager.addPhantomDummyWithTarget(tabster, currentElement, isBackward, nextElement);\n          return;\n        }\n\n        if (nextUncontrolled || nextElement.tagName === \"IFRAME\") {\n          // For iframes and uncontrolled areas we always want to use default action to\n          // move focus into.\n          if (dispatchMoveFocusEvent({\n            by: \"root\",\n            owner: rootElement,\n            next: nextElement,\n            relatedEvent: event\n          })) {\n            DummyInputManager.moveWithPhantomDummy(this._tabster, nextUncontrolled !== null && nextUncontrolled !== void 0 ? nextUncontrolled : nextElement, false, isBackward, event);\n          }\n\n          return;\n        }\n\n        if (controlTab || (next === null || next === void 0 ? void 0 : next.outOfDOMOrder)) {\n          if (dispatchMoveFocusEvent({\n            by: \"root\",\n            owner: rootElement,\n            next: nextElement,\n            relatedEvent: event\n          })) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n            nativeFocus(nextElement);\n          }\n        }\n      } else {\n        if (!uncontrolledCompletelyContainer && dispatchMoveFocusEvent({\n          by: \"root\",\n          owner: rootElement,\n          next: null,\n          relatedEvent: event\n        })) {\n          ctx.root.moveOutWithDefaultAction(isBackward, event);\n        }\n      }\n    };\n\n    this._onChanged = (element, details) => {\n      var _a, _b;\n\n      if (element) {\n        triggerEvent(element, FocusInEventName, details);\n      } else {\n        const last = (_a = this._lastVal) === null || _a === void 0 ? void 0 : _a.get();\n\n        if (last) {\n          const d = { ...details\n          };\n          const lastCtx = RootAPI.getTabsterContext(this._tabster, last);\n          const modalizerId = (_b = lastCtx === null || lastCtx === void 0 ? void 0 : lastCtx.modalizer) === null || _b === void 0 ? void 0 : _b.userId;\n\n          if (modalizerId) {\n            d.modalizerId = modalizerId;\n          }\n\n          triggerEvent(last, FocusOutEventName, d);\n        }\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = getWindow;\n    tabster.queueInit(this._init);\n  }\n\n  dispose() {\n    super.dispose();\n\n    const win = this._win();\n\n    const doc = win.document;\n    doc.removeEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true);\n    doc.removeEventListener(KEYBORG_FOCUSOUT, this._onFocusOut, true);\n    win.removeEventListener(\"keydown\", this._onKeyDown, true);\n    this.unsubscribe(this._onChanged);\n    delete FocusedElementState._lastResetElement;\n    delete this._nextVal;\n    delete this._lastVal;\n  }\n\n  static forgetMemorized(instance, parent) {\n    var _a, _b;\n\n    let wel = FocusedElementState._lastResetElement;\n    let el = wel && wel.get();\n\n    if (el && dom.nodeContains(parent, el)) {\n      delete FocusedElementState._lastResetElement;\n    }\n\n    el = (_b = (_a = instance._nextVal) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.get();\n\n    if (el && dom.nodeContains(parent, el)) {\n      delete instance._nextVal;\n    }\n\n    wel = instance._lastVal;\n    el = wel && wel.get();\n\n    if (el && dom.nodeContains(parent, el)) {\n      delete instance._lastVal;\n    }\n  }\n\n  getFocusedElement() {\n    return this.getVal();\n  }\n\n  getLastFocusedElement() {\n    var _a;\n\n    let el = (_a = this._lastVal) === null || _a === void 0 ? void 0 : _a.get();\n\n    if (!el || el && !documentContains(el.ownerDocument, el)) {\n      this._lastVal = el = undefined;\n    }\n\n    return el;\n  }\n\n  focus(element, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    if (!this._tabster.focusable.isFocusable(element, noFocusedProgrammaticallyFlag, false, noAccessibleCheck)) {\n      return false;\n    }\n\n    element.focus();\n    return true;\n  }\n\n  focusDefault(container) {\n    const el = this._tabster.focusable.findDefault({\n      container\n    });\n\n    if (el) {\n      this._tabster.focusedElement.focus(el);\n\n      return true;\n    }\n\n    return false;\n  }\n\n  getFirstOrLastTabbable(isFirst, props) {\n    var _a;\n\n    const {\n      container,\n      ignoreAccessibility\n    } = props;\n    let toFocus;\n\n    if (container) {\n      const ctx = RootAPI.getTabsterContext(this._tabster, container);\n\n      if (ctx) {\n        toFocus = (_a = FocusedElementState.findNextTabbable(this._tabster, ctx, container, undefined, undefined, !isFirst, ignoreAccessibility)) === null || _a === void 0 ? void 0 : _a.element;\n      }\n    }\n\n    if (toFocus && !dom.nodeContains(container, toFocus)) {\n      toFocus = undefined;\n    }\n\n    return toFocus || undefined;\n  }\n\n  _focusFirstOrLast(isFirst, props) {\n    const toFocus = this.getFirstOrLastTabbable(isFirst, props);\n\n    if (toFocus) {\n      this.focus(toFocus, false, true);\n      return true;\n    }\n\n    return false;\n  }\n\n  focusFirst(props) {\n    return this._focusFirstOrLast(true, props);\n  }\n\n  focusLast(props) {\n    return this._focusFirstOrLast(false, props);\n  }\n\n  resetFocus(container) {\n    if (!this._tabster.focusable.isVisible(container)) {\n      return false;\n    }\n\n    if (!this._tabster.focusable.isFocusable(container, true, true, true)) {\n      const prevTabIndex = container.getAttribute(\"tabindex\");\n      const prevAriaHidden = container.getAttribute(\"aria-hidden\");\n      container.tabIndex = -1;\n      container.setAttribute(\"aria-hidden\", \"true\");\n      FocusedElementState._lastResetElement = new WeakHTMLElement(this._win, container);\n      this.focus(container, true, true);\n\n      this._setOrRemoveAttribute(container, \"tabindex\", prevTabIndex);\n\n      this._setOrRemoveAttribute(container, \"aria-hidden\", prevAriaHidden);\n    } else {\n      this.focus(container);\n    }\n\n    return true;\n  }\n\n  _setOrRemoveAttribute(element, name, value) {\n    if (value === null) {\n      element.removeAttribute(name);\n    } else {\n      element.setAttribute(name, value);\n    }\n  }\n\n  _setFocusedElement(element, relatedTarget, isFocusedProgrammatically) {\n    var _a, _b;\n\n    if (this._tabster._noop) {\n      return;\n    }\n\n    const details = {\n      relatedTarget\n    };\n\n    if (element) {\n      const lastResetElement = (_a = FocusedElementState._lastResetElement) === null || _a === void 0 ? void 0 : _a.get();\n      FocusedElementState._lastResetElement = undefined;\n\n      if (lastResetElement === element || shouldIgnoreFocus(element)) {\n        return;\n      }\n\n      details.isFocusedProgrammatically = isFocusedProgrammatically;\n      const ctx = RootAPI.getTabsterContext(this._tabster, element);\n      const modalizerId = (_b = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer) === null || _b === void 0 ? void 0 : _b.userId;\n\n      if (modalizerId) {\n        details.modalizerId = modalizerId;\n      }\n    }\n\n    const nextVal = this._nextVal = {\n      element: element ? new WeakHTMLElement(this._win, element) : undefined,\n      details\n    };\n\n    if (element && element !== this._val) {\n      this._validateFocusedElement(element);\n    } // _validateFocusedElement() might cause the refocus which will trigger\n    // another call to this function. Making sure that the value is correct.\n\n\n    if (this._nextVal === nextVal) {\n      this.setVal(element, details);\n    }\n\n    this._nextVal = undefined;\n  }\n\n  setVal(val, details) {\n    super.setVal(val, details);\n\n    if (val) {\n      this._lastVal = new WeakHTMLElement(this._win, val);\n    }\n  }\n\n  static findNextTabbable(tabster, ctx, container, currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    const actualContainer = container || ctx.root.getElement();\n\n    if (!actualContainer) {\n      return null;\n    }\n\n    let next = null;\n    const isTabbingTimer = FocusedElementState._isTabbingTimer;\n    const win = tabster.getWindow();\n\n    if (isTabbingTimer) {\n      win.clearTimeout(isTabbingTimer);\n    }\n\n    FocusedElementState.isTabbing = true;\n    FocusedElementState._isTabbingTimer = win.setTimeout(() => {\n      delete FocusedElementState._isTabbingTimer;\n      FocusedElementState.isTabbing = false;\n    }, 0);\n    const modalizer = ctx.modalizer;\n    const groupper = ctx.groupper;\n    const mover = ctx.mover;\n\n    const callFindNext = what => {\n      next = what.findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility);\n\n      if (currentElement && !(next === null || next === void 0 ? void 0 : next.element)) {\n        const parentElement = what !== modalizer && dom.getParentElement(what.getElement());\n\n        if (parentElement) {\n          const parentCtx = RootAPI.getTabsterContext(tabster, currentElement, {\n            referenceElement: parentElement\n          });\n\n          if (parentCtx) {\n            const currentScopeElement = what.getElement();\n            const newCurrent = isBackward ? currentScopeElement : currentScopeElement && getLastChild$2(currentScopeElement) || currentScopeElement;\n\n            if (newCurrent) {\n              next = FocusedElementState.findNextTabbable(tabster, parentCtx, container, newCurrent, parentElement, isBackward, ignoreAccessibility);\n\n              if (next) {\n                next.outOfDOMOrder = true;\n              }\n            }\n          }\n        }\n      }\n    };\n\n    if (groupper && mover) {\n      callFindNext(ctx.groupperBeforeMover ? groupper : mover);\n    } else if (groupper) {\n      callFindNext(groupper);\n    } else if (mover) {\n      callFindNext(mover);\n    } else if (modalizer) {\n      callFindNext(modalizer);\n    } else {\n      const findProps = {\n        container: actualContainer,\n        currentElement,\n        referenceElement,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      const nextElement = tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n      next = {\n        element: nextElement,\n        outOfDOMOrder: findPropsOut.outOfDOMOrder,\n        uncontrolled: findPropsOut.uncontrolled\n      };\n    }\n\n    return next;\n  }\n\n}\nFocusedElementState.isTabbing = false;\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nclass GroupperDummyManager extends DummyInputManager {\n  constructor(element, groupper, tabster, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Groupper, sys, true);\n\n    this._setHandlers((dummyInput, isBackward, relatedTarget) => {\n      var _a, _b;\n\n      const container = element.get();\n      const input = dummyInput.input;\n\n      if (container && input) {\n        const ctx = RootAPI.getTabsterContext(tabster, input);\n\n        if (ctx) {\n          let next;\n          next = (_a = groupper.findNextTabbable(relatedTarget || undefined, undefined, isBackward, true)) === null || _a === void 0 ? void 0 : _a.element;\n\n          if (!next) {\n            next = (_b = FocusedElementState.findNextTabbable(tabster, ctx, undefined, dummyInput.isOutside ? input : getAdjacentElement(container, !isBackward), undefined, isBackward, true)) === null || _b === void 0 ? void 0 : _b.element;\n          }\n\n          if (next) {\n            nativeFocus(next);\n          }\n        }\n      }\n    });\n  }\n\n}\n\nclass Groupper extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys) {\n    super(tabster, element, props);\n    this._shouldTabInside = false;\n    this.makeTabbable(false);\n    this._onDispose = onDispose;\n\n    if (!tabster.controlTab) {\n      this.dummyManager = new GroupperDummyManager(this._element, this, tabster, sys);\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    this._onDispose(this);\n\n    const element = this._element.get();\n\n    (_a = this.dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n    delete this.dummyManager;\n\n    if (element) {\n      if (process.env.NODE_ENV === 'development') {\n        _setInformativeStyle$1(this._element, true);\n      }\n    }\n\n    delete this._first;\n  }\n\n  findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    var _a;\n\n    const groupperElement = this.getElement();\n\n    if (!groupperElement) {\n      return null;\n    }\n\n    const currentIsDummy = ((_a = currentElement === null || currentElement === void 0 ? void 0 : currentElement.__tabsterDummyContainer) === null || _a === void 0 ? void 0 : _a.get()) === groupperElement;\n\n    if (!this._shouldTabInside && currentElement && dom.nodeContains(groupperElement, currentElement) && !currentIsDummy) {\n      return {\n        element: undefined,\n        outOfDOMOrder: true\n      };\n    }\n\n    const groupperFirstFocusable = this.getFirst(true);\n\n    if (!currentElement || !dom.nodeContains(groupperElement, currentElement) || currentIsDummy) {\n      return {\n        element: groupperFirstFocusable,\n        outOfDOMOrder: true\n      };\n    }\n\n    const tabster = this._tabster;\n    let next = null;\n    let outOfDOMOrder = false;\n    let uncontrolled;\n\n    if (this._shouldTabInside && groupperFirstFocusable) {\n      const findProps = {\n        container: groupperElement,\n        currentElement,\n        referenceElement,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      next = tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n      outOfDOMOrder = !!findPropsOut.outOfDOMOrder;\n\n      if (!next && this._props.tabbability === GroupperTabbabilities.LimitedTrapFocus) {\n        next = tabster.focusable[isBackward ? \"findLast\" : \"findFirst\"]({\n          container: groupperElement,\n          ignoreAccessibility,\n          useActiveModalizer: true\n        }, findPropsOut);\n        outOfDOMOrder = true;\n      }\n\n      uncontrolled = findPropsOut.uncontrolled;\n    }\n\n    return {\n      element: next,\n      uncontrolled,\n      outOfDOMOrder\n    };\n  }\n\n  makeTabbable(isTabbable) {\n    this._shouldTabInside = isTabbable || !this._props.tabbability;\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$1(this._element, !this._shouldTabInside);\n    }\n  }\n\n  isActive(noIfFirstIsFocused) {\n    var _a;\n\n    const element = this.getElement() || null;\n    let isParentActive = true;\n\n    for (let e = dom.getParentElement(element); e; e = dom.getParentElement(e)) {\n      const g = (_a = getTabsterOnElement(this._tabster, e)) === null || _a === void 0 ? void 0 : _a.groupper;\n\n      if (g) {\n        if (!g._shouldTabInside) {\n          isParentActive = false;\n        }\n      }\n    }\n\n    let ret = isParentActive ? this._props.tabbability ? this._shouldTabInside : false : undefined;\n\n    if (ret && noIfFirstIsFocused) {\n      const focused = this._tabster.focusedElement.getFocusedElement();\n\n      if (focused) {\n        ret = focused !== this.getFirst(true);\n      }\n    }\n\n    return ret;\n  }\n\n  getFirst(orContainer) {\n    var _a;\n\n    const groupperElement = this.getElement();\n    let first;\n\n    if (groupperElement) {\n      if (orContainer && this._tabster.focusable.isFocusable(groupperElement)) {\n        return groupperElement;\n      }\n\n      first = (_a = this._first) === null || _a === void 0 ? void 0 : _a.get();\n\n      if (!first) {\n        first = this._tabster.focusable.findFirst({\n          container: groupperElement,\n          useActiveModalizer: true\n        }) || undefined;\n\n        if (first) {\n          this.setFirst(first);\n        }\n      }\n    }\n\n    return first;\n  }\n\n  setFirst(element) {\n    if (element) {\n      this._first = new WeakHTMLElement(this._tabster.getWindow, element);\n    } else {\n      delete this._first;\n    }\n  }\n\n  acceptElement(element, state) {\n    const cachedGrouppers = state.cachedGrouppers;\n    const parentElement = dom.getParentElement(this.getElement());\n    const parentCtx = parentElement && RootAPI.getTabsterContext(this._tabster, parentElement);\n    const parentCtxGroupper = parentCtx === null || parentCtx === void 0 ? void 0 : parentCtx.groupper;\n    const parentGroupper = (parentCtx === null || parentCtx === void 0 ? void 0 : parentCtx.groupperBeforeMover) ? parentCtxGroupper : undefined;\n    let parentGroupperElement;\n\n    const getIsActive = groupper => {\n      let cached = cachedGrouppers[groupper.id];\n      let isActive;\n\n      if (cached) {\n        isActive = cached.isActive;\n      } else {\n        isActive = this.isActive(true);\n        cached = cachedGrouppers[groupper.id] = {\n          isActive\n        };\n      }\n\n      return isActive;\n    };\n\n    if (parentGroupper) {\n      parentGroupperElement = parentGroupper.getElement();\n\n      if (!getIsActive(parentGroupper) && parentGroupperElement && state.container !== parentGroupperElement && dom.nodeContains(state.container, parentGroupperElement)) {\n        // Do not fall into a child groupper of inactive parent groupper if it's in the scope of the search.\n        state.skippedFocusable = true;\n        return NodeFilter.FILTER_REJECT;\n      }\n    }\n\n    const isActive = getIsActive(this);\n    const groupperElement = this.getElement();\n\n    if (groupperElement) {\n      if (isActive !== true) {\n        if (groupperElement === element && parentCtxGroupper) {\n          if (!parentGroupperElement) {\n            parentGroupperElement = parentCtxGroupper.getElement();\n          }\n\n          if (parentGroupperElement && !getIsActive(parentCtxGroupper) && dom.nodeContains(state.container, parentGroupperElement) && parentGroupperElement !== state.container) {\n            state.skippedFocusable = true;\n            return NodeFilter.FILTER_REJECT;\n          }\n        }\n\n        if (groupperElement !== element && dom.nodeContains(groupperElement, element)) {\n          state.skippedFocusable = true;\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        const cached = cachedGrouppers[this.id];\n        let first;\n\n        if (\"first\" in cached) {\n          first = cached.first;\n        } else {\n          first = cached.first = this.getFirst(true);\n        }\n\n        if (first && state.acceptCondition(first)) {\n          state.rejectElementsFrom = groupperElement;\n          state.skippedFocusable = true;\n\n          if (first !== state.from) {\n            state.found = true;\n            state.foundElement = first;\n            return NodeFilter.FILTER_ACCEPT;\n          } else {\n            return NodeFilter.FILTER_REJECT;\n          }\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass GroupperAPI {\n  constructor(tabster, getWindow) {\n    this._current = {};\n    this._grouppers = {};\n\n    this._init = () => {\n      const win = this._win(); // Making sure groupper's onFocus is called before modalizer's onFocus.\n\n\n      this._tabster.focusedElement.subscribeFirst(this._onFocus);\n\n      const doc = win.document;\n      const activeElement = dom.getActiveElement(doc);\n\n      if (activeElement) {\n        this._onFocus(activeElement);\n      }\n\n      doc.addEventListener(\"mousedown\", this._onMouseDown, true);\n      win.addEventListener(\"keydown\", this._onKeyDown, true);\n      win.addEventListener(GroupperMoveFocusEventName, this._onMoveFocus);\n    };\n\n    this._onGroupperDispose = groupper => {\n      delete this._grouppers[groupper.id];\n    };\n\n    this._onFocus = element => {\n      if (element) {\n        this._updateCurrent(element, true, true);\n      }\n    };\n\n    this._onMouseDown = e => {\n      if (e.target) {\n        this._updateCurrent(e.target, true);\n      }\n    };\n\n    this._onKeyDown = event => {\n      if (event.keyCode !== Keys.Enter && event.keyCode !== Keys.Esc) {\n        return;\n      } // Give a chance to other listeners to handle the event.\n\n\n      if (event.ctrlKey || event.altKey || event.shiftKey || event.metaKey) {\n        return;\n      }\n\n      const element = this._tabster.focusedElement.getFocusedElement();\n\n      if (element) {\n        this.handleKeyPress(element, event);\n      }\n    };\n\n    this._onMoveFocus = e => {\n      var _a;\n\n      const element = e.composedPath()[0];\n      const action = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.action;\n\n      if (element && action !== undefined && !e.defaultPrevented) {\n        if (action === GroupperMoveFocusActions.Enter) {\n          this._enterGroupper(element);\n        } else {\n          this._escapeGroupper(element);\n        }\n\n        e.stopImmediatePropagation();\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = getWindow;\n    tabster.queueInit(this._init);\n  }\n\n  dispose() {\n    const win = this._win();\n\n    if (this._handleKeyPressTimer) {\n      win.clearTimeout(this._handleKeyPressTimer);\n      delete this._handleKeyPressTimer;\n    }\n\n    this._current = {};\n\n    if (this._updateTimer) {\n      win.clearTimeout(this._updateTimer);\n      delete this._updateTimer;\n    }\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    win.document.removeEventListener(\"mousedown\", this._onMouseDown, true);\n    win.removeEventListener(\"keydown\", this._onKeyDown, true);\n    win.removeEventListener(GroupperMoveFocusEventName, this._onMoveFocus);\n    Object.keys(this._grouppers).forEach(groupperId => {\n      if (this._grouppers[groupperId]) {\n        this._grouppers[groupperId].dispose();\n\n        delete this._grouppers[groupperId];\n      }\n    });\n  }\n\n  createGroupper(element, props, sys) {\n    if (process.env.NODE_ENV === 'development') ;\n\n    const newGroupper = new Groupper(this._tabster, element, this._onGroupperDispose, props, sys);\n    this._grouppers[newGroupper.id] = newGroupper;\n\n    const focusedElement = this._tabster.focusedElement.getFocusedElement(); // Newly created groupper contains currently focused element, update the state on the next tick (to\n    // make sure all grouppers are processed).\n\n\n    if (focusedElement && dom.nodeContains(element, focusedElement) && !this._updateTimer) {\n      this._updateTimer = this._win().setTimeout(() => {\n        delete this._updateTimer; // Making sure the focused element hasn't changed.\n\n        if (focusedElement === this._tabster.focusedElement.getFocusedElement()) {\n          this._updateCurrent(focusedElement, true, true);\n        }\n      }, 0);\n    }\n\n    return newGroupper;\n  }\n\n  forgetCurrentGrouppers() {\n    this._current = {};\n  }\n\n  _updateCurrent(element, includeTarget, checkTarget) {\n    var _a;\n\n    if (this._updateTimer) {\n      this._win().clearTimeout(this._updateTimer);\n\n      delete this._updateTimer;\n    }\n\n    const newIds = {};\n    let isTarget = true;\n\n    for (let el = element; el; el = dom.getParentElement(el)) {\n      const groupper = (_a = getTabsterOnElement(this._tabster, el)) === null || _a === void 0 ? void 0 : _a.groupper;\n\n      if (groupper) {\n        newIds[groupper.id] = true;\n\n        if (isTarget && checkTarget && el !== element) {\n          isTarget = false;\n        }\n\n        if (includeTarget || !isTarget) {\n          this._current[groupper.id] = groupper;\n          const isTabbable = groupper.isActive() || element !== el && (!groupper.getProps().delegated || groupper.getFirst(false) !== element);\n          groupper.makeTabbable(isTabbable);\n        }\n\n        isTarget = false;\n      }\n    }\n\n    for (const id of Object.keys(this._current)) {\n      const groupper = this._current[id];\n\n      if (!(groupper.id in newIds)) {\n        groupper.makeTabbable(false);\n        groupper.setFirst(undefined);\n        delete this._current[id];\n      }\n    }\n  }\n\n  _enterGroupper(element, relatedEvent) {\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n    const groupper = (ctx === null || ctx === void 0 ? void 0 : ctx.groupper) || (ctx === null || ctx === void 0 ? void 0 : ctx.modalizerInGroupper);\n    const groupperElement = groupper === null || groupper === void 0 ? void 0 : groupper.getElement();\n\n    if (groupper && groupperElement && (element === groupperElement || groupper.getProps().delegated && element === groupper.getFirst(false))) {\n      const next = tabster.focusable.findNext({\n        container: groupperElement,\n        currentElement: element,\n        useActiveModalizer: true\n      });\n\n      if (next && (!relatedEvent || relatedEvent && dispatchMoveFocusEvent({\n        by: \"groupper\",\n        owner: groupperElement,\n        next,\n        relatedEvent\n      }))) {\n        if (relatedEvent) {\n          // When the application hasn't prevented default,\n          // we consider the event completely handled, hence we\n          // prevent the initial event's default action and stop\n          // propagation.\n          relatedEvent.preventDefault();\n          relatedEvent.stopImmediatePropagation();\n        }\n\n        next.focus();\n        return next;\n      }\n    }\n\n    return null;\n  }\n\n  _escapeGroupper(element, relatedEvent, fromModalizer) {\n    var _a;\n\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n    const modalizerInGroupper = ctx === null || ctx === void 0 ? void 0 : ctx.modalizerInGroupper;\n    let groupper = (ctx === null || ctx === void 0 ? void 0 : ctx.groupper) || modalizerInGroupper;\n    const groupperElement = groupper === null || groupper === void 0 ? void 0 : groupper.getElement();\n\n    if (groupper && groupperElement && dom.nodeContains(groupperElement, element)) {\n      let next;\n\n      if (element !== groupperElement || fromModalizer) {\n        next = groupper.getFirst(true);\n      } else {\n        const parentElement = dom.getParentElement(groupperElement);\n        const parentCtx = parentElement ? RootAPI.getTabsterContext(tabster, parentElement) : undefined;\n        groupper = parentCtx === null || parentCtx === void 0 ? void 0 : parentCtx.groupper;\n        next = groupper === null || groupper === void 0 ? void 0 : groupper.getFirst(true);\n      }\n\n      if (next && (!relatedEvent || relatedEvent && dispatchMoveFocusEvent({\n        by: \"groupper\",\n        owner: groupperElement,\n        next,\n        relatedEvent\n      }))) {\n        if (groupper) {\n          groupper.makeTabbable(false);\n\n          if (modalizerInGroupper) {\n            (_a = tabster.modalizer) === null || _a === void 0 ? void 0 : _a.setActive(undefined);\n          }\n        } // This part happens asynchronously inside setTimeout,\n        // so no need to prevent default or stop propagation.\n\n\n        next.focus();\n        return next;\n      }\n    }\n\n    return null;\n  }\n\n  moveFocus(element, action) {\n    return action === GroupperMoveFocusActions.Enter ? this._enterGroupper(element) : this._escapeGroupper(element);\n  }\n\n  handleKeyPress(element, event, fromModalizer) {\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n\n    if (ctx && ((ctx === null || ctx === void 0 ? void 0 : ctx.groupper) || (ctx === null || ctx === void 0 ? void 0 : ctx.modalizerInGroupper))) {\n      const win = this._win();\n\n      if (this._handleKeyPressTimer) {\n        win.clearTimeout(this._handleKeyPressTimer);\n        delete this._handleKeyPressTimer;\n      }\n\n      if (ctx.ignoreKeydown(event)) {\n        return;\n      }\n\n      if (event.keyCode === Keys.Enter) {\n        this._enterGroupper(element, event);\n      } else if (event.keyCode === Keys.Esc) {\n        // We will handle Esc asynchronously, if something in the application will\n        // move focus during the keypress handling, we will not interfere.\n        const focusedElement = tabster.focusedElement.getFocusedElement();\n        this._handleKeyPressTimer = win.setTimeout(() => {\n          delete this._handleKeyPressTimer;\n\n          if (focusedElement !== tabster.focusedElement.getFocusedElement() && ( // A part of Modalizer that has called this handler to escape the active groupper\n          // might have been removed from DOM, if the focus is on body, we still want to handle Esc.\n          fromModalizer && !focusedElement || !fromModalizer)) {\n            // Something else in the application has moved focus, we will not handle Esc.\n            return;\n          }\n\n          this._escapeGroupper(element, event, fromModalizer);\n        }, 0);\n      }\n    }\n  }\n\n}\n\nfunction _setInformativeStyle$1(weakElement, remove) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-groupper\");\n      } else {\n        element.style.setProperty(\"--tabster-groupper\", \"unlimited\");\n      }\n    }\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass KeyboardNavigationState extends Subscribable {\n  constructor(getWindow) {\n    super();\n\n    this._onChange = isNavigatingWithKeyboard => {\n      this.setVal(isNavigatingWithKeyboard, undefined);\n    };\n\n    this._keyborg = createKeyborg(getWindow());\n\n    this._keyborg.subscribe(this._onChange);\n  }\n\n  dispose() {\n    super.dispose();\n\n    if (this._keyborg) {\n      this._keyborg.unsubscribe(this._onChange);\n\n      disposeKeyborg(this._keyborg);\n      delete this._keyborg;\n    }\n  }\n\n  setNavigatingWithKeyboard(isNavigatingWithKeyboard) {\n    var _a;\n\n    (_a = this._keyborg) === null || _a === void 0 ? void 0 : _a.setVal(isNavigatingWithKeyboard);\n  }\n\n  isNavigatingWithKeyboard() {\n    var _a;\n\n    return !!((_a = this._keyborg) === null || _a === void 0 ? void 0 : _a.isNavigatingWithKeyboard());\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nlet _wasFocusedCounter = 0;\nconst _ariaHidden = \"aria-hidden\";\n\nfunction _setInformativeStyle(weakElement, remove, internalId, userId, isActive, wasFocused) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-modalizer\");\n      } else {\n        element.style.setProperty(\"--tabster-modalizer\", internalId + \",\" + userId + \",\" + (isActive ? \"active\" : \"inactive\") + \",\" + \",\" + (wasFocused ? `focused(${wasFocused})` : \"not-focused\"));\n      }\n    }\n  }\n}\n/**\r\n * Manages the dummy inputs for the Modalizer.\r\n */\n\n\nclass ModalizerDummyManager extends DummyInputManager {\n  constructor(element, tabster, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Modalizer, sys);\n\n    this._setHandlers((dummyInput, isBackward) => {\n      var _a, _b, _c;\n\n      const el = element.get();\n      const container = el && ((_a = RootAPI.getRoot(tabster, el)) === null || _a === void 0 ? void 0 : _a.getElement());\n      const input = dummyInput.input;\n      let toFocus;\n\n      if (container && input) {\n        const dummyContainer = (_b = input.__tabsterDummyContainer) === null || _b === void 0 ? void 0 : _b.get();\n        const ctx = RootAPI.getTabsterContext(tabster, dummyContainer || input);\n\n        if (ctx) {\n          toFocus = (_c = FocusedElementState.findNextTabbable(tabster, ctx, container, input, undefined, isBackward, true)) === null || _c === void 0 ? void 0 : _c.element;\n        }\n\n        if (toFocus) {\n          nativeFocus(toFocus);\n        }\n      }\n    });\n  }\n\n}\n\nclass Modalizer extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys, activeElements) {\n    super(tabster, element, props);\n    this._wasFocused = 0;\n    this.userId = props.id;\n    this._onDispose = onDispose;\n    this._activeElements = activeElements;\n\n    if (!tabster.controlTab) {\n      this.dummyManager = new ModalizerDummyManager(this._element, tabster, sys);\n    }\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle(this._element, false, this.id, this.userId, this._isActive, this._wasFocused);\n    }\n  }\n\n  makeActive(isActive) {\n    if (this._isActive !== isActive) {\n      this._isActive = isActive;\n      const element = this.getElement();\n\n      if (element) {\n        const activeElements = this._activeElements;\n        const index = activeElements.map(e => e.get()).indexOf(element);\n\n        if (isActive) {\n          if (index < 0) {\n            activeElements.push(new WeakHTMLElement(this._tabster.getWindow, element));\n          }\n        } else {\n          if (index >= 0) {\n            activeElements.splice(index, 1);\n          }\n        }\n      }\n\n      if (process.env.NODE_ENV === 'development') {\n        _setInformativeStyle(this._element, false, this.id, this.userId, this._isActive, this._wasFocused);\n      }\n\n      this.triggerFocusEvent(isActive ? ModalizerActiveEventName : ModalizerInactiveEventName);\n    }\n  }\n\n  focused(noIncrement) {\n    if (!noIncrement) {\n      this._wasFocused = ++_wasFocusedCounter;\n    }\n\n    return this._wasFocused;\n  }\n\n  setProps(props) {\n    if (props.id) {\n      this.userId = props.id;\n    }\n\n    this._props = { ...props\n    };\n  }\n\n  dispose() {\n    var _a;\n\n    this.makeActive(false);\n\n    this._onDispose(this);\n\n    (_a = this.dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n    delete this.dummyManager;\n    this._activeElements = [];\n\n    this._remove();\n  }\n\n  isActive() {\n    return !!this._isActive;\n  }\n\n  contains(element) {\n    return dom.nodeContains(this.getElement(), element);\n  }\n\n  findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    var _a, _b;\n\n    const modalizerElement = this.getElement();\n\n    if (!modalizerElement) {\n      return null;\n    }\n\n    const tabster = this._tabster;\n    let next = null;\n    let outOfDOMOrder = false;\n    let uncontrolled;\n    const container = currentElement && ((_a = RootAPI.getRoot(tabster, currentElement)) === null || _a === void 0 ? void 0 : _a.getElement());\n\n    if (container) {\n      const findProps = {\n        container,\n        currentElement,\n        referenceElement,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      next = tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n\n      if (!next && this._props.isTrapped && ((_b = tabster.modalizer) === null || _b === void 0 ? void 0 : _b.activeId)) {\n        next = tabster.focusable[isBackward ? \"findLast\" : \"findFirst\"]({\n          container,\n          ignoreAccessibility,\n          useActiveModalizer: true\n        }, findPropsOut);\n        outOfDOMOrder = true;\n      } else {\n        outOfDOMOrder = !!findPropsOut.outOfDOMOrder;\n      }\n\n      uncontrolled = findPropsOut.uncontrolled;\n    }\n\n    return {\n      element: next,\n      uncontrolled,\n      outOfDOMOrder\n    };\n  }\n\n  triggerFocusEvent(eventName, allElements) {\n    const element = this.getElement();\n    let defaultPrevented = false;\n\n    if (element) {\n      const elements = allElements ? this._activeElements.map(e => e.get()) : [element];\n\n      for (const el of elements) {\n        if (el && !triggerEvent(el, eventName, {\n          id: this.userId,\n          element,\n          eventName\n        })) {\n          defaultPrevented = true;\n        }\n      }\n    }\n\n    return defaultPrevented;\n  }\n\n  _remove() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle(this._element, true);\n    }\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass ModalizerAPI {\n  constructor(tabster, // @deprecated use accessibleCheck.\n  alwaysAccessibleSelector, accessibleCheck) {\n    this._onModalizerDispose = modalizer => {\n      const id = modalizer.id;\n      const userId = modalizer.userId;\n      const part = this._parts[userId];\n      delete this._modalizers[id];\n\n      if (part) {\n        delete part[id];\n\n        if (Object.keys(part).length === 0) {\n          delete this._parts[userId];\n\n          if (this.activeId === userId) {\n            this.setActive(undefined);\n          }\n        }\n      }\n    };\n\n    this._onKeyDown = event => {\n      var _a;\n\n      if (event.keyCode !== Keys.Esc) {\n        return;\n      }\n\n      const tabster = this._tabster;\n      const element = tabster.focusedElement.getFocusedElement();\n\n      if (element) {\n        const ctx = RootAPI.getTabsterContext(tabster, element);\n        const modalizer = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer;\n\n        if (ctx && !ctx.groupper && (modalizer === null || modalizer === void 0 ? void 0 : modalizer.isActive()) && !ctx.ignoreKeydown(event)) {\n          const activeId = modalizer.userId;\n\n          if (activeId) {\n            const part = this._parts[activeId];\n\n            if (part) {\n              const focusedSince = Object.keys(part).map(id => {\n                var _a;\n\n                const m = part[id];\n                const el = m.getElement();\n                let groupper;\n\n                if (el) {\n                  groupper = (_a = getTabsterOnElement(this._tabster, el)) === null || _a === void 0 ? void 0 : _a.groupper;\n                }\n\n                return m && el && groupper ? {\n                  el,\n                  focusedSince: m.focused(true)\n                } : {\n                  focusedSince: 0\n                };\n              }).filter(f => f.focusedSince > 0).sort((a, b) => a.focusedSince > b.focusedSince ? -1 : a.focusedSince < b.focusedSince ? 1 : 0);\n\n              if (focusedSince.length) {\n                const groupperElement = focusedSince[0].el;\n\n                if (groupperElement) {\n                  (_a = tabster.groupper) === null || _a === void 0 ? void 0 : _a.handleKeyPress(groupperElement, event, true);\n                }\n              }\n            }\n          }\n        }\n      }\n    };\n    /**\r\n     * Subscribes to the focus state and handles modalizer related focus events\r\n     * @param e - Element that is focused\r\n     * @param details - Additional data about the focus event\r\n     */\n\n\n    this._onFocus = (focusedElement, details) => {\n      var _a, _b;\n\n      const ctx = focusedElement && RootAPI.getTabsterContext(this._tabster, focusedElement); // Modalizer behaviour is opt in, only apply to elements that have a tabster context\n\n      if (!ctx || !focusedElement) {\n        return;\n      }\n\n      const augmentedMap = this._augMap;\n\n      for (let e = focusedElement; e; e = dom.getParentElement(e)) {\n        // If the newly focused element is inside some of the hidden containers,\n        // remove aria-hidden from those synchronously for the screen readers\n        // to be able to read the element. The rest of aria-hiddens, will be removed\n        // acynchronously for the sake of performance.\n        if (augmentedMap.has(e)) {\n          augmentedMap.delete(e);\n          augmentAttribute(this._tabster, e, _ariaHidden);\n        }\n      }\n\n      const modalizer = ctx.modalizer; // An inactive groupper with the modalizer on the same node will not give the modalizer\n      // in the context, yet we still want to track that the modalizer's container was focused.\n\n      (_b = modalizer || ((_a = getTabsterOnElement(this._tabster, focusedElement)) === null || _a === void 0 ? void 0 : _a.modalizer)) === null || _b === void 0 ? void 0 : _b.focused();\n\n      if ((modalizer === null || modalizer === void 0 ? void 0 : modalizer.userId) === this.activeId) {\n        this.currentIsOthersAccessible = modalizer === null || modalizer === void 0 ? void 0 : modalizer.getProps().isOthersAccessible;\n        return;\n      } // Developers calling `element.focus()` should change/deactivate active modalizer\n\n\n      if (details.isFocusedProgrammatically || this.currentIsOthersAccessible || (modalizer === null || modalizer === void 0 ? void 0 : modalizer.getProps().isAlwaysAccessible)) {\n        this.setActive(modalizer);\n      } else {\n        // Focused outside of the active modalizer, try pull focus back to current modalizer\n        const win = this._win();\n\n        win.clearTimeout(this._restoreModalizerFocusTimer); // TODO some rendering frameworks (i.e. React) might async rerender the DOM so we need to wait for a duration\n        // Figure out a better way of doing this rather than a 100ms timeout\n\n        this._restoreModalizerFocusTimer = win.setTimeout(() => this._restoreModalizerFocus(focusedElement), 100);\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._modalizers = {};\n    this._parts = {};\n    this._augMap = new WeakMap();\n    this._aug = [];\n    this._alwaysAccessibleSelector = alwaysAccessibleSelector;\n    this._accessibleCheck = accessibleCheck;\n    this.activeElements = [];\n\n    if (!tabster.controlTab) {\n      tabster.root.addDummyInputs();\n    }\n\n    const win = this._win();\n\n    win.addEventListener(\"keydown\", this._onKeyDown, true);\n    tabster.queueInit(() => {\n      this._tabster.focusedElement.subscribe(this._onFocus);\n    });\n  }\n\n  dispose() {\n    const win = this._win();\n\n    win.removeEventListener(\"keydown\", this._onKeyDown, true); // Dispose all modalizers managed by the API\n\n    Object.keys(this._modalizers).forEach(modalizerId => {\n      if (this._modalizers[modalizerId]) {\n        this._modalizers[modalizerId].dispose();\n\n        delete this._modalizers[modalizerId];\n      }\n    });\n    win.clearTimeout(this._restoreModalizerFocusTimer);\n    win.clearTimeout(this._hiddenUpdateTimer);\n    this._parts = {};\n    delete this.activeId;\n    this.activeElements = [];\n    this._augMap = new WeakMap();\n    this._aug = [];\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n  }\n\n  createModalizer(element, props, sys) {\n    var _a;\n\n    if (process.env.NODE_ENV === 'development') ;\n\n    const modalizer = new Modalizer(this._tabster, element, this._onModalizerDispose, props, sys, this.activeElements);\n    const id = modalizer.id;\n    const userId = props.id;\n    this._modalizers[id] = modalizer;\n    let part = this._parts[userId];\n\n    if (!part) {\n      part = this._parts[userId] = {};\n    }\n\n    part[id] = modalizer; // Adding a modalizer which is already focused, activate it\n\n    if (dom.nodeContains(element, (_a = this._tabster.focusedElement.getFocusedElement()) !== null && _a !== void 0 ? _a : null)) {\n      if (userId !== this.activeId) {\n        this.setActive(modalizer);\n      } else {\n        modalizer.makeActive(true);\n      }\n    }\n\n    return modalizer;\n  }\n\n  isAugmented(element) {\n    return this._augMap.has(element);\n  }\n\n  hiddenUpdate() {\n    if (this._hiddenUpdateTimer) {\n      return;\n    }\n\n    this._hiddenUpdateTimer = this._win().setTimeout(() => {\n      delete this._hiddenUpdateTimer;\n\n      this._hiddenUpdate();\n    }, 250);\n  }\n\n  setActive(modalizer) {\n    const userId = modalizer === null || modalizer === void 0 ? void 0 : modalizer.userId;\n    const activeId = this.activeId;\n\n    if (activeId === userId) {\n      return;\n    }\n\n    this.activeId = userId;\n\n    if (activeId) {\n      const part = this._parts[activeId];\n\n      if (part) {\n        for (const id of Object.keys(part)) {\n          part[id].makeActive(false);\n        }\n      }\n    }\n\n    if (userId) {\n      const part = this._parts[userId];\n\n      if (part) {\n        for (const id of Object.keys(part)) {\n          part[id].makeActive(true);\n        }\n      }\n    }\n\n    this.currentIsOthersAccessible = modalizer === null || modalizer === void 0 ? void 0 : modalizer.getProps().isOthersAccessible;\n    this.hiddenUpdate();\n  }\n\n  focus(elementFromModalizer, noFocusFirst, noFocusDefault) {\n    const ctx = RootAPI.getTabsterContext(this._tabster, elementFromModalizer);\n    const modalizer = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer;\n\n    if (modalizer) {\n      this.setActive(modalizer);\n      const props = modalizer.getProps();\n      const modalizerRoot = modalizer.getElement();\n\n      if (modalizerRoot) {\n        if (noFocusFirst === undefined) {\n          noFocusFirst = props.isNoFocusFirst;\n        }\n\n        if (!noFocusFirst && this._tabster.keyboardNavigation.isNavigatingWithKeyboard() && this._tabster.focusedElement.focusFirst({\n          container: modalizerRoot\n        })) {\n          return true;\n        }\n\n        if (noFocusDefault === undefined) {\n          noFocusDefault = props.isNoFocusDefault;\n        }\n\n        if (!noFocusDefault && this._tabster.focusedElement.focusDefault(modalizerRoot)) {\n          return true;\n        }\n\n        this._tabster.focusedElement.resetFocus(modalizerRoot);\n      }\n    } else if (process.env.NODE_ENV === 'development') {\n      console.error(\"Element is not in Modalizer.\", elementFromModalizer);\n    }\n\n    return false;\n  }\n\n  acceptElement(element, state) {\n    var _a;\n\n    const modalizerUserId = state.modalizerUserId;\n    const currentModalizer = (_a = state.currentCtx) === null || _a === void 0 ? void 0 : _a.modalizer;\n\n    if (modalizerUserId) {\n      for (const e of this.activeElements) {\n        const el = e.get();\n\n        if (el && (dom.nodeContains(element, el) || el === element)) {\n          // We have a part of currently active modalizer somewhere deeper in the DOM,\n          // skipping all other checks.\n          return NodeFilter.FILTER_SKIP;\n        }\n      }\n    }\n\n    const ret = modalizerUserId === (currentModalizer === null || currentModalizer === void 0 ? void 0 : currentModalizer.userId) || !modalizerUserId && (currentModalizer === null || currentModalizer === void 0 ? void 0 : currentModalizer.getProps().isAlwaysAccessible) ? undefined : NodeFilter.FILTER_SKIP;\n\n    if (ret !== undefined) {\n      state.skippedFocusable = true;\n    }\n\n    return ret;\n  }\n\n  _hiddenUpdate() {\n    var _a;\n\n    const tabster = this._tabster;\n    const body = tabster.getWindow().document.body;\n    const activeId = this.activeId;\n    const parts = this._parts;\n    const visibleElements = [];\n    const hiddenElements = [];\n    const alwaysAccessibleSelector = this._alwaysAccessibleSelector;\n    const alwaysAccessibleElements = alwaysAccessibleSelector ? Array.from(dom.querySelectorAll(body, alwaysAccessibleSelector)) : [];\n    const activeModalizerElements = [];\n\n    for (const userId of Object.keys(parts)) {\n      const modalizerParts = parts[userId];\n\n      for (const id of Object.keys(modalizerParts)) {\n        const modalizer = modalizerParts[id];\n        const el = modalizer.getElement();\n        const props = modalizer.getProps();\n        const isAlwaysAccessible = props.isAlwaysAccessible;\n\n        if (el) {\n          if (userId === activeId) {\n            activeModalizerElements.push(el);\n\n            if (!this.currentIsOthersAccessible) {\n              visibleElements.push(el);\n            }\n          } else if (isAlwaysAccessible) {\n            alwaysAccessibleElements.push(el);\n          } else {\n            hiddenElements.push(el);\n          }\n        }\n      }\n    }\n\n    const augmentedMap = this._augMap;\n    const allVisibleElements = visibleElements.length > 0 ? [...visibleElements, ...alwaysAccessibleElements] : undefined;\n    const newAugmented = [];\n    const newAugmentedMap = new WeakMap();\n\n    const toggle = (element, hide) => {\n      var _a;\n\n      const tagName = element.tagName;\n\n      if (tagName === \"SCRIPT\" || tagName === \"STYLE\") {\n        return;\n      }\n\n      let isAugmented = false;\n\n      if (augmentedMap.has(element)) {\n        if (hide) {\n          isAugmented = true;\n        } else {\n          augmentedMap.delete(element);\n          augmentAttribute(tabster, element, _ariaHidden);\n        }\n      } else if (hide && !((_a = this._accessibleCheck) === null || _a === void 0 ? void 0 : _a.call(this, element, activeModalizerElements)) && augmentAttribute(tabster, element, _ariaHidden, \"true\")) {\n        augmentedMap.set(element, true);\n        isAugmented = true;\n      }\n\n      if (isAugmented) {\n        newAugmented.push(new WeakHTMLElement(tabster.getWindow, element));\n        newAugmentedMap.set(element, true);\n      }\n    };\n\n    const walk = element => {\n      for (let el = dom.getFirstElementChild(element); el; el = dom.getNextElementSibling(el)) {\n        let skip = false;\n        let containsModalizer = false;\n\n        if (allVisibleElements) {\n          for (const c of allVisibleElements) {\n            if (el === c) {\n              skip = true;\n              break;\n            }\n\n            if (dom.nodeContains(el, c)) {\n              containsModalizer = true;\n              break;\n            }\n          }\n\n          if (containsModalizer) {\n            walk(el);\n          } else if (!skip) {\n            toggle(el, true);\n          }\n        } else {\n          toggle(el, false);\n        }\n      }\n    };\n\n    if (!allVisibleElements) {\n      alwaysAccessibleElements.forEach(e => toggle(e, false));\n    }\n\n    hiddenElements.forEach(e => toggle(e, true));\n\n    if (body) {\n      walk(body);\n    }\n\n    (_a = this._aug) === null || _a === void 0 ? void 0 : _a.map(e => e.get()).forEach(e => {\n      if (e && !newAugmentedMap.get(e)) {\n        toggle(e, false);\n      }\n    });\n    this._aug = newAugmented;\n    this._augMap = newAugmentedMap;\n  }\n  /**\r\n   * Called when an element is focused outside of an active modalizer.\r\n   * Attempts to pull focus back into the active modalizer\r\n   * @param outsideElement - An element being focused outside of the modalizer\r\n   */\n\n\n  _restoreModalizerFocus(outsideElement) {\n    const ownerDocument = outsideElement === null || outsideElement === void 0 ? void 0 : outsideElement.ownerDocument;\n\n    if (!outsideElement || !ownerDocument) {\n      return;\n    }\n\n    const ctx = RootAPI.getTabsterContext(this._tabster, outsideElement);\n    const modalizer = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer;\n    const activeId = this.activeId;\n\n    if (!modalizer && !activeId || modalizer && activeId === modalizer.userId) {\n      return;\n    }\n\n    const container = ctx === null || ctx === void 0 ? void 0 : ctx.root.getElement();\n\n    if (container) {\n      let toFocus = this._tabster.focusable.findFirst({\n        container,\n        useActiveModalizer: true\n      });\n\n      if (toFocus) {\n        if (outsideElement.compareDocumentPosition(toFocus) & document.DOCUMENT_POSITION_PRECEDING) {\n          toFocus = this._tabster.focusable.findLast({\n            container,\n            useActiveModalizer: true\n          });\n\n          if (!toFocus) {\n            // This only might mean that findFirst/findLast are buggy and inconsistent.\n            throw new Error(\"Something went wrong.\");\n          }\n        }\n\n        this._tabster.focusedElement.focus(toFocus);\n\n        return;\n      }\n    } // Current Modalizer doesn't seem to have focusable elements.\n    // Blurring the currently focused element which is outside of the current Modalizer.\n\n\n    outsideElement.blur();\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nconst _inputSelector = /*#__PURE__*/[\"input\", \"textarea\", \"*[contenteditable]\"].join(\", \");\n\nclass MoverDummyManager extends DummyInputManager {\n  constructor(element, tabster, getMemorized, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Mover, sys);\n\n    this._onFocusDummyInput = dummyInput => {\n      var _a, _b;\n\n      const container = this._element.get();\n\n      const input = dummyInput.input;\n\n      if (container && input) {\n        const ctx = RootAPI.getTabsterContext(this._tabster, container);\n        let toFocus;\n\n        if (ctx) {\n          toFocus = (_a = FocusedElementState.findNextTabbable(this._tabster, ctx, undefined, input, undefined, !dummyInput.isFirst, true)) === null || _a === void 0 ? void 0 : _a.element;\n        }\n\n        const memorized = (_b = this._getMemorized()) === null || _b === void 0 ? void 0 : _b.get();\n\n        if (memorized) {\n          toFocus = memorized;\n        }\n\n        if (toFocus) {\n          nativeFocus(toFocus);\n        }\n      }\n    };\n\n    this._tabster = tabster;\n    this._getMemorized = getMemorized;\n\n    this._setHandlers(this._onFocusDummyInput);\n  }\n\n} // TypeScript enums produce depressing JavaScript code, so, we're just using\n// a few old style constants here.\n\n\nconst _moverUpdateAdd = 1;\nconst _moverUpdateAttr = 2;\nconst _moverUpdateRemove = 3;\nclass Mover extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys) {\n    var _a;\n\n    super(tabster, element, props);\n    this._visible = {};\n\n    this._onIntersection = entries => {\n      for (const entry of entries) {\n        const el = entry.target;\n        const id = getElementUId(this._win, el);\n        let newVisibility;\n        let fullyVisible = this._fullyVisible;\n\n        if (entry.intersectionRatio >= 0.25) {\n          newVisibility = entry.intersectionRatio >= 0.75 ? Visibilities.Visible : Visibilities.PartiallyVisible;\n\n          if (newVisibility === Visibilities.Visible) {\n            fullyVisible = id;\n          }\n        } else {\n          newVisibility = Visibilities.Invisible;\n        }\n\n        if (this._visible[id] !== newVisibility) {\n          if (newVisibility === undefined) {\n            delete this._visible[id];\n\n            if (fullyVisible === id) {\n              delete this._fullyVisible;\n            }\n          } else {\n            this._visible[id] = newVisibility;\n            this._fullyVisible = fullyVisible;\n          }\n\n          const state = this.getState(el);\n\n          if (state) {\n            triggerEvent(el, MoverEventName, state);\n          }\n        }\n      }\n    };\n\n    this._win = tabster.getWindow;\n    this.visibilityTolerance = (_a = props.visibilityTolerance) !== null && _a !== void 0 ? _a : 0.8;\n\n    if (this._props.trackState || this._props.visibilityAware) {\n      this._intersectionObserver = new IntersectionObserver(this._onIntersection, {\n        threshold: [0, 0.25, 0.5, 0.75, 1]\n      });\n\n      this._observeState();\n    }\n\n    this._onDispose = onDispose;\n\n    const getMemorized = () => props.memorizeCurrent ? this._current : undefined;\n\n    if (!tabster.controlTab) {\n      this.dummyManager = new MoverDummyManager(this._element, tabster, getMemorized, sys);\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    this._onDispose(this);\n\n    if (this._intersectionObserver) {\n      this._intersectionObserver.disconnect();\n\n      delete this._intersectionObserver;\n    }\n\n    delete this._current;\n    delete this._fullyVisible;\n    delete this._allElements;\n    delete this._updateQueue;\n\n    if (this._unobserve) {\n      this._unobserve();\n\n      delete this._unobserve;\n    }\n\n    const win = this._win();\n\n    if (this._setCurrentTimer) {\n      win.clearTimeout(this._setCurrentTimer);\n      delete this._setCurrentTimer;\n    }\n\n    if (this._updateTimer) {\n      win.clearTimeout(this._updateTimer);\n      delete this._updateTimer;\n    }\n\n    (_a = this.dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n    delete this.dummyManager;\n  }\n\n  setCurrent(element) {\n    if (element) {\n      this._current = new WeakHTMLElement(this._win, element);\n    } else {\n      this._current = undefined;\n    }\n\n    if ((this._props.trackState || this._props.visibilityAware) && !this._setCurrentTimer) {\n      this._setCurrentTimer = this._win().setTimeout(() => {\n        var _a;\n\n        delete this._setCurrentTimer;\n        const changed = [];\n\n        if (this._current !== this._prevCurrent) {\n          changed.push(this._current);\n          changed.push(this._prevCurrent);\n          this._prevCurrent = this._current;\n        }\n\n        for (const weak of changed) {\n          const el = weak === null || weak === void 0 ? void 0 : weak.get();\n\n          if (el && ((_a = this._allElements) === null || _a === void 0 ? void 0 : _a.get(el)) === this) {\n            const props = this._props;\n\n            if (el && (props.visibilityAware !== undefined || props.trackState)) {\n              const state = this.getState(el);\n\n              if (state) {\n                triggerEvent(el, MoverEventName, state);\n              }\n            }\n          }\n        }\n      });\n    }\n  }\n\n  getCurrent() {\n    var _a;\n\n    return ((_a = this._current) === null || _a === void 0 ? void 0 : _a.get()) || null;\n  }\n\n  findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    var _a;\n\n    const container = this.getElement();\n    const currentIsDummy = container && ((_a = currentElement === null || currentElement === void 0 ? void 0 : currentElement.__tabsterDummyContainer) === null || _a === void 0 ? void 0 : _a.get()) === container;\n\n    if (!container) {\n      return null;\n    }\n\n    let next = null;\n    let outOfDOMOrder = false;\n    let uncontrolled;\n\n    if (this._props.tabbable || currentIsDummy || currentElement && !dom.nodeContains(container, currentElement)) {\n      const findProps = {\n        currentElement,\n        referenceElement,\n        container,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      next = this._tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n      outOfDOMOrder = !!findPropsOut.outOfDOMOrder;\n      uncontrolled = findPropsOut.uncontrolled;\n    }\n\n    return {\n      element: next,\n      uncontrolled,\n      outOfDOMOrder\n    };\n  }\n\n  acceptElement(element, state) {\n    var _a, _b, _c;\n\n    if (!FocusedElementState.isTabbing) {\n      return ((_a = state.currentCtx) === null || _a === void 0 ? void 0 : _a.excludedFromMover) ? NodeFilter.FILTER_REJECT : undefined;\n    }\n\n    const {\n      memorizeCurrent,\n      visibilityAware,\n      hasDefault = true\n    } = this._props;\n    const moverElement = this.getElement();\n\n    if (moverElement && (memorizeCurrent || visibilityAware || hasDefault) && (!dom.nodeContains(moverElement, state.from) || ((_b = state.from.__tabsterDummyContainer) === null || _b === void 0 ? void 0 : _b.get()) === moverElement)) {\n      let found;\n\n      if (memorizeCurrent) {\n        const current = (_c = this._current) === null || _c === void 0 ? void 0 : _c.get();\n\n        if (current && state.acceptCondition(current)) {\n          found = current;\n        }\n      }\n\n      if (!found && hasDefault) {\n        found = this._tabster.focusable.findDefault({\n          container: moverElement,\n          useActiveModalizer: true\n        });\n      }\n\n      if (!found && visibilityAware) {\n        found = this._tabster.focusable.findElement({\n          container: moverElement,\n          useActiveModalizer: true,\n          isBackward: state.isBackward,\n          acceptCondition: el => {\n            var _a;\n\n            const id = getElementUId(this._win, el);\n            const visibility = this._visible[id];\n            return moverElement !== el && !!((_a = this._allElements) === null || _a === void 0 ? void 0 : _a.get(el)) && state.acceptCondition(el) && (visibility === Visibilities.Visible || visibility === Visibilities.PartiallyVisible && (visibilityAware === Visibilities.PartiallyVisible || !this._fullyVisible));\n          }\n        });\n      }\n\n      if (found) {\n        state.found = true;\n        state.foundElement = found;\n        state.rejectElementsFrom = moverElement;\n        state.skippedFocusable = true;\n        return NodeFilter.FILTER_ACCEPT;\n      }\n    }\n\n    return undefined;\n  }\n\n  _observeState() {\n    const element = this.getElement();\n\n    if (this._unobserve || !element || typeof MutationObserver === \"undefined\") {\n      return;\n    }\n\n    const win = this._win();\n\n    const allElements = this._allElements = new WeakMap();\n    const tabsterFocusable = this._tabster.focusable;\n    let updateQueue = this._updateQueue = [];\n    const observer = dom.createMutationObserver(mutations => {\n      for (const mutation of mutations) {\n        const target = mutation.target;\n        const removed = mutation.removedNodes;\n        const added = mutation.addedNodes;\n\n        if (mutation.type === \"attributes\") {\n          if (mutation.attributeName === \"tabindex\") {\n            updateQueue.push({\n              element: target,\n              type: _moverUpdateAttr\n            });\n          }\n        } else {\n          for (let i = 0; i < removed.length; i++) {\n            updateQueue.push({\n              element: removed[i],\n              type: _moverUpdateRemove\n            });\n          }\n\n          for (let i = 0; i < added.length; i++) {\n            updateQueue.push({\n              element: added[i],\n              type: _moverUpdateAdd\n            });\n          }\n        }\n      }\n\n      requestUpdate();\n    });\n\n    const setElement = (element, remove) => {\n      var _a, _b;\n\n      const current = allElements.get(element);\n\n      if (current && remove) {\n        (_a = this._intersectionObserver) === null || _a === void 0 ? void 0 : _a.unobserve(element);\n        allElements.delete(element);\n      }\n\n      if (!current && !remove) {\n        allElements.set(element, this);\n        (_b = this._intersectionObserver) === null || _b === void 0 ? void 0 : _b.observe(element);\n      }\n    };\n\n    const updateElement = element => {\n      const isFocusable = tabsterFocusable.isFocusable(element);\n      const current = allElements.get(element);\n\n      if (current) {\n        if (!isFocusable) {\n          setElement(element, true);\n        }\n      } else {\n        if (isFocusable) {\n          setElement(element);\n        }\n      }\n    };\n\n    const addNewElements = element => {\n      const {\n        mover\n      } = getMoverGroupper(element);\n\n      if (mover && mover !== this) {\n        if (mover.getElement() === element && tabsterFocusable.isFocusable(element)) {\n          setElement(element);\n        } else {\n          return;\n        }\n      }\n\n      const walker = createElementTreeWalker(win.document, element, node => {\n        const {\n          mover,\n          groupper\n        } = getMoverGroupper(node);\n\n        if (mover && mover !== this) {\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        const groupperFirstFocusable = groupper === null || groupper === void 0 ? void 0 : groupper.getFirst(true);\n\n        if (groupper && groupper.getElement() !== node && groupperFirstFocusable && groupperFirstFocusable !== node) {\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        if (tabsterFocusable.isFocusable(node)) {\n          setElement(node);\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      });\n\n      if (walker) {\n        walker.currentNode = element;\n\n        while (walker.nextNode()) {\n          /* Iterating for the sake of calling processNode() callback. */\n        }\n      }\n    };\n\n    const removeWalk = element => {\n      const current = allElements.get(element);\n\n      if (current) {\n        setElement(element, true);\n      }\n\n      for (let el = dom.getFirstElementChild(element); el; el = dom.getNextElementSibling(el)) {\n        removeWalk(el);\n      }\n    };\n\n    const requestUpdate = () => {\n      if (!this._updateTimer && updateQueue.length) {\n        this._updateTimer = win.setTimeout(() => {\n          delete this._updateTimer;\n\n          for (const {\n            element,\n            type\n          } of updateQueue) {\n            switch (type) {\n              case _moverUpdateAttr:\n                updateElement(element);\n                break;\n\n              case _moverUpdateAdd:\n                addNewElements(element);\n                break;\n\n              case _moverUpdateRemove:\n                removeWalk(element);\n                break;\n            }\n          }\n\n          updateQueue = this._updateQueue = [];\n        }, 0);\n      }\n    };\n\n    const getMoverGroupper = element => {\n      const ret = {};\n\n      for (let el = element; el; el = dom.getParentElement(el)) {\n        const toe = getTabsterOnElement(this._tabster, el);\n\n        if (toe) {\n          if (toe.groupper && !ret.groupper) {\n            ret.groupper = toe.groupper;\n          }\n\n          if (toe.mover) {\n            ret.mover = toe.mover;\n            break;\n          }\n        }\n      }\n\n      return ret;\n    };\n\n    updateQueue.push({\n      element,\n      type: _moverUpdateAdd\n    });\n    requestUpdate();\n    observer.observe(element, {\n      childList: true,\n      subtree: true,\n      attributes: true,\n      attributeFilter: [\"tabindex\"]\n    });\n\n    this._unobserve = () => {\n      observer.disconnect();\n    };\n  }\n\n  getState(element) {\n    const id = getElementUId(this._win, element);\n\n    if (id in this._visible) {\n      const visibility = this._visible[id] || Visibilities.Invisible;\n      const isCurrent = this._current ? this._current.get() === element : undefined;\n      return {\n        isCurrent,\n        visibility\n      };\n    }\n\n    return undefined;\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n/**\r\n * Calculates distance between two rectangles.\r\n *\r\n * @param ax1 first rectangle left\r\n * @param ay1 first rectangle top\r\n * @param ax2 first rectangle right\r\n * @param ay2 first rectangle bottom\r\n * @param bx1 second rectangle left\r\n * @param by1 second rectangle top\r\n * @param bx2 second rectangle right\r\n * @param by2 second rectangle bottom\r\n * @returns number, shortest distance between the rectangles.\r\n */\n\n\nfunction getDistance(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {\n  const xDistance = ax2 < bx1 ? bx1 - ax2 : bx2 < ax1 ? ax1 - bx2 : 0;\n  const yDistance = ay2 < by1 ? by1 - ay2 : by2 < ay1 ? ay1 - by2 : 0;\n  return xDistance === 0 ? yDistance : yDistance === 0 ? xDistance : Math.sqrt(xDistance * xDistance + yDistance * yDistance);\n}\n\nclass MoverAPI {\n  constructor(tabster, getWindow) {\n    this._init = () => {\n      const win = this._win();\n\n      win.addEventListener(\"keydown\", this._onKeyDown, true);\n      win.addEventListener(MoverMoveFocusEventName, this._onMoveFocus);\n\n      this._tabster.focusedElement.subscribe(this._onFocus);\n    };\n\n    this._onMoverDispose = mover => {\n      delete this._movers[mover.id];\n    };\n\n    this._onFocus = element => {\n      var _a; // When something in the app gets focused, we are making sure that\n      // the relevant context Mover is aware of it.\n      // Looking for the relevant context Mover from the currently\n      // focused element parent, not from the element itself, because the\n      // Mover element itself cannot be its own current (but might be\n      // current for its parent Mover).\n\n\n      let currentFocusableElement = element;\n      let deepestFocusableElement = element;\n\n      for (let el = dom.getParentElement(element); el; el = dom.getParentElement(el)) {\n        // We go through all Movers up from the focused element and\n        // set their current element to the deepest focusable of that\n        // Mover.\n        const mover = (_a = getTabsterOnElement(this._tabster, el)) === null || _a === void 0 ? void 0 : _a.mover;\n\n        if (mover) {\n          mover.setCurrent(deepestFocusableElement);\n          currentFocusableElement = undefined;\n        }\n\n        if (!currentFocusableElement && this._tabster.focusable.isFocusable(el)) {\n          currentFocusableElement = deepestFocusableElement = el;\n        }\n      }\n    };\n\n    this._onKeyDown = async event => {\n      var _a;\n\n      if (this._ignoredInputTimer) {\n        this._win().clearTimeout(this._ignoredInputTimer);\n\n        delete this._ignoredInputTimer;\n      }\n\n      (_a = this._ignoredInputResolve) === null || _a === void 0 ? void 0 : _a.call(this, false); // Give a chance to other listeners to handle the event (for example,\n      // to scroll instead of moving focus).\n\n      if (event.ctrlKey || event.altKey || event.shiftKey || event.metaKey) {\n        return;\n      }\n\n      const keyCode = event.keyCode;\n      let moverKey;\n\n      if (keyCode === Keys.Down) {\n        moverKey = MoverKeys.ArrowDown;\n      } else if (keyCode === Keys.Right) {\n        moverKey = MoverKeys.ArrowRight;\n      } else if (keyCode === Keys.Up) {\n        moverKey = MoverKeys.ArrowUp;\n      } else if (keyCode === Keys.Left) {\n        moverKey = MoverKeys.ArrowLeft;\n      } else if (keyCode === Keys.PageDown) {\n        moverKey = MoverKeys.PageDown;\n      } else if (keyCode === Keys.PageUp) {\n        moverKey = MoverKeys.PageUp;\n      } else if (keyCode === Keys.Home) {\n        moverKey = MoverKeys.Home;\n      } else if (keyCode === Keys.End) {\n        moverKey = MoverKeys.End;\n      }\n\n      if (!moverKey) {\n        return;\n      }\n\n      const focused = this._tabster.focusedElement.getFocusedElement();\n\n      if (!focused || (await this._isIgnoredInput(focused, keyCode))) {\n        return;\n      }\n\n      this._moveFocus(focused, moverKey, event);\n    };\n\n    this._onMoveFocus = e => {\n      var _a;\n\n      const element = e.composedPath()[0];\n      const key = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.key;\n\n      if (element && key !== undefined && !e.defaultPrevented) {\n        this._moveFocus(element, key);\n\n        e.stopImmediatePropagation();\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = getWindow;\n    this._movers = {};\n    tabster.queueInit(this._init);\n  }\n\n  dispose() {\n    var _a;\n\n    const win = this._win();\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    (_a = this._ignoredInputResolve) === null || _a === void 0 ? void 0 : _a.call(this, false);\n\n    if (this._ignoredInputTimer) {\n      win.clearTimeout(this._ignoredInputTimer);\n      delete this._ignoredInputTimer;\n    }\n\n    win.removeEventListener(\"keydown\", this._onKeyDown, true);\n    win.removeEventListener(MoverMoveFocusEventName, this._onMoveFocus);\n    Object.keys(this._movers).forEach(moverId => {\n      if (this._movers[moverId]) {\n        this._movers[moverId].dispose();\n\n        delete this._movers[moverId];\n      }\n    });\n  }\n\n  createMover(element, props, sys) {\n    if (process.env.NODE_ENV === 'development') ;\n\n    const newMover = new Mover(this._tabster, element, this._onMoverDispose, props, sys);\n    this._movers[newMover.id] = newMover;\n    return newMover;\n  }\n\n  moveFocus(fromElement, key) {\n    return this._moveFocus(fromElement, key);\n  }\n\n  _moveFocus(fromElement, key, relatedEvent) {\n    var _a, _b;\n\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, fromElement, {\n      checkRtl: true\n    });\n\n    if (!ctx || !ctx.mover || ctx.excludedFromMover || relatedEvent && ctx.ignoreKeydown(relatedEvent)) {\n      return null;\n    }\n\n    const mover = ctx.mover;\n    const container = mover.getElement();\n\n    if (ctx.groupperBeforeMover) {\n      const groupper = ctx.groupper;\n\n      if (groupper && !groupper.isActive(true)) {\n        // For the cases when we have Mover/Active Groupper/Inactive Groupper, we need to check\n        // the grouppers between the current element and the current mover.\n        for (let el = dom.getParentElement(groupper.getElement()); el && el !== container; el = dom.getParentElement(el)) {\n          if ((_b = (_a = getTabsterOnElement(tabster, el)) === null || _a === void 0 ? void 0 : _a.groupper) === null || _b === void 0 ? void 0 : _b.isActive(true)) {\n            return null;\n          }\n        }\n      } else {\n        return null;\n      }\n    }\n\n    if (!container) {\n      return null;\n    }\n\n    const focusable = tabster.focusable;\n    const moverProps = mover.getProps();\n    const direction = moverProps.direction || MoverDirections.Both;\n    const isBoth = direction === MoverDirections.Both;\n    const isVertical = isBoth || direction === MoverDirections.Vertical;\n    const isHorizontal = isBoth || direction === MoverDirections.Horizontal;\n    const isGridLinear = direction === MoverDirections.GridLinear;\n    const isGrid = isGridLinear || direction === MoverDirections.Grid;\n    const isCyclic = moverProps.cyclic;\n    let next;\n    let scrollIntoViewArg;\n    let focusedElementRect;\n    let focusedElementX1 = 0;\n    let focusedElementX2 = 0;\n\n    if (isGrid) {\n      focusedElementRect = fromElement.getBoundingClientRect();\n      focusedElementX1 = Math.ceil(focusedElementRect.left);\n      focusedElementX2 = Math.floor(focusedElementRect.right);\n    }\n\n    if (ctx.rtl) {\n      if (key === MoverKeys.ArrowRight) {\n        key = MoverKeys.ArrowLeft;\n      } else if (key === MoverKeys.ArrowLeft) {\n        key = MoverKeys.ArrowRight;\n      }\n    }\n\n    if (key === MoverKeys.ArrowDown && isVertical || key === MoverKeys.ArrowRight && (isHorizontal || isGrid)) {\n      next = focusable.findNext({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true\n      });\n\n      if (next && isGrid) {\n        const nextElementX1 = Math.ceil(next.getBoundingClientRect().left);\n\n        if (!isGridLinear && focusedElementX2 > nextElementX1) {\n          next = undefined;\n        }\n      } else if (!next && isCyclic) {\n        next = focusable.findFirst({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.ArrowUp && isVertical || key === MoverKeys.ArrowLeft && (isHorizontal || isGrid)) {\n      next = focusable.findPrev({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true\n      });\n\n      if (next && isGrid) {\n        const nextElementX2 = Math.floor(next.getBoundingClientRect().right);\n\n        if (!isGridLinear && nextElementX2 > focusedElementX1) {\n          next = undefined;\n        }\n      } else if (!next && isCyclic) {\n        next = focusable.findLast({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.Home) {\n      if (isGrid) {\n        focusable.findElement({\n          container,\n          currentElement: fromElement,\n          useActiveModalizer: true,\n          isBackward: true,\n          acceptCondition: el => {\n            var _a;\n\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil((_a = el.getBoundingClientRect().left) !== null && _a !== void 0 ? _a : 0);\n\n            if (el !== fromElement && focusedElementX1 <= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      } else {\n        next = focusable.findFirst({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.End) {\n      if (isGrid) {\n        focusable.findElement({\n          container,\n          currentElement: fromElement,\n          useActiveModalizer: true,\n          acceptCondition: el => {\n            var _a;\n\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil((_a = el.getBoundingClientRect().left) !== null && _a !== void 0 ? _a : 0);\n\n            if (el !== fromElement && focusedElementX1 >= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      } else {\n        next = focusable.findLast({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.PageUp) {\n      focusable.findElement({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true,\n        isBackward: true,\n        acceptCondition: el => {\n          if (!focusable.isFocusable(el)) {\n            return false;\n          }\n\n          if (isElementVerticallyVisibleInContainer(this._win, el, mover.visibilityTolerance)) {\n            next = el;\n            return false;\n          }\n\n          return true;\n        }\n      }); // will be on the first column move forward and preserve previous column\n\n      if (isGrid && next) {\n        const firstColumnX1 = Math.ceil(next.getBoundingClientRect().left);\n        focusable.findElement({\n          currentElement: next,\n          container,\n          useActiveModalizer: true,\n          acceptCondition: el => {\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil(el.getBoundingClientRect().left);\n\n            if (focusedElementX1 < nextElementX1 || firstColumnX1 >= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      }\n\n      scrollIntoViewArg = false;\n    } else if (key === MoverKeys.PageDown) {\n      focusable.findElement({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true,\n        acceptCondition: el => {\n          if (!focusable.isFocusable(el)) {\n            return false;\n          }\n\n          if (isElementVerticallyVisibleInContainer(this._win, el, mover.visibilityTolerance)) {\n            next = el;\n            return false;\n          }\n\n          return true;\n        }\n      }); // will be on the last column move backwards and preserve previous column\n\n      if (isGrid && next) {\n        const lastColumnX1 = Math.ceil(next.getBoundingClientRect().left);\n        focusable.findElement({\n          currentElement: next,\n          container,\n          useActiveModalizer: true,\n          isBackward: true,\n          acceptCondition: el => {\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil(el.getBoundingClientRect().left);\n\n            if (focusedElementX1 > nextElementX1 || lastColumnX1 <= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      }\n\n      scrollIntoViewArg = true;\n    } else if (isGrid) {\n      const isBackward = key === MoverKeys.ArrowUp;\n      const ax1 = focusedElementX1; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n      const ay1 = Math.ceil(focusedElementRect.top);\n      const ax2 = focusedElementX2; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n      const ay2 = Math.floor(focusedElementRect.bottom);\n      let targetElement;\n      let lastDistance;\n      let lastIntersection = 0;\n      focusable.findAll({\n        container,\n        currentElement: fromElement,\n        isBackward,\n        onElement: el => {\n          // Find element which has maximal intersection with the focused element horizontally,\n          // or the closest one.\n          const rect = el.getBoundingClientRect();\n          const bx1 = Math.ceil(rect.left);\n          const by1 = Math.ceil(rect.top);\n          const bx2 = Math.floor(rect.right);\n          const by2 = Math.floor(rect.bottom);\n\n          if (isBackward && ay1 < by2 || !isBackward && ay2 > by1) {\n            // Only consider elements which are below/above curretly focused.\n            return true;\n          }\n\n          const xIntersectionWidth = Math.ceil(Math.min(ax2, bx2)) - Math.floor(Math.max(ax1, bx1));\n          const minWidth = Math.ceil(Math.min(ax2 - ax1, bx2 - bx1));\n\n          if (xIntersectionWidth > 0 && minWidth >= xIntersectionWidth) {\n            // Element intersects with the focused element on X axis.\n            const intersection = xIntersectionWidth / minWidth;\n\n            if (intersection > lastIntersection) {\n              targetElement = el;\n              lastIntersection = intersection;\n            }\n          } else if (lastIntersection === 0) {\n            // If we didn't have intersection, try just the closest one.\n            const distance = getDistance(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2);\n\n            if (lastDistance === undefined || distance < lastDistance) {\n              lastDistance = distance;\n              targetElement = el;\n            }\n          } else if (lastIntersection > 0) {\n            // Element doesn't intersect, but we had intersection already, stop search.\n            return false;\n          }\n\n          return true;\n        }\n      });\n      next = targetElement;\n    }\n\n    if (next && (!relatedEvent || relatedEvent && dispatchMoveFocusEvent({\n      by: \"mover\",\n      owner: container,\n      next,\n      relatedEvent\n    }))) {\n      if (scrollIntoViewArg !== undefined) {\n        scrollIntoView(this._win, next, scrollIntoViewArg);\n      }\n\n      if (relatedEvent) {\n        relatedEvent.preventDefault();\n        relatedEvent.stopImmediatePropagation();\n      }\n\n      nativeFocus(next);\n      return next;\n    }\n\n    return null;\n  }\n\n  async _isIgnoredInput(element, keyCode) {\n    if (element.getAttribute(\"aria-expanded\") === \"true\" && element.hasAttribute(\"aria-activedescendant\")) {\n      // It is likely a combobox with expanded options and arrow keys are\n      // controlled by it.\n      return true;\n    }\n\n    if (matchesSelector(element, _inputSelector)) {\n      let selectionStart = 0;\n      let selectionEnd = 0;\n      let textLength = 0;\n      let asyncRet;\n\n      if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n        const type = element.type;\n        const value = element.value;\n        textLength = (value || \"\").length;\n\n        if (type === \"email\" || type === \"number\") {\n          // For these types Chromium doesn't provide selectionStart and selectionEnd.\n          // Hence the ugly workaround to find if the caret position is changed with\n          // the keypress.\n          // TODO: Have a look at range, week, time, time, date, datetime-local.\n          if (textLength) {\n            const selection = dom.getSelection(element);\n\n            if (selection) {\n              const initialLength = selection.toString().length;\n              const isBackward = keyCode === Keys.Left || keyCode === Keys.Up;\n              selection.modify(\"extend\", isBackward ? \"backward\" : \"forward\", \"character\");\n\n              if (initialLength !== selection.toString().length) {\n                // The caret is moved, so, we're not on the edge of the value.\n                // Restore original selection.\n                selection.modify(\"extend\", isBackward ? \"forward\" : \"backward\", \"character\");\n                return true;\n              } else {\n                textLength = 0;\n              }\n            }\n          }\n        } else {\n          const selStart = element.selectionStart;\n\n          if (selStart === null) {\n            // Do not ignore not text editable inputs like checkboxes and radios (but ignore hidden).\n            return type === \"hidden\";\n          }\n\n          selectionStart = selStart || 0;\n          selectionEnd = element.selectionEnd || 0;\n        }\n      } else if (element.contentEditable === \"true\") {\n        asyncRet = new (getPromise(this._win))(resolve => {\n          this._ignoredInputResolve = value => {\n            delete this._ignoredInputResolve;\n            resolve(value);\n          };\n\n          const win = this._win();\n\n          if (this._ignoredInputTimer) {\n            win.clearTimeout(this._ignoredInputTimer);\n          }\n\n          const {\n            anchorNode: prevAnchorNode,\n            focusNode: prevFocusNode,\n            anchorOffset: prevAnchorOffset,\n            focusOffset: prevFocusOffset\n          } = dom.getSelection(element) || {}; // Get selection gives incorrect value if we call it syncronously onKeyDown.\n\n          this._ignoredInputTimer = win.setTimeout(() => {\n            var _a, _b, _c;\n\n            delete this._ignoredInputTimer;\n            const {\n              anchorNode,\n              focusNode,\n              anchorOffset,\n              focusOffset\n            } = dom.getSelection(element) || {};\n\n            if (anchorNode !== prevAnchorNode || focusNode !== prevFocusNode || anchorOffset !== prevAnchorOffset || focusOffset !== prevFocusOffset) {\n              (_a = this._ignoredInputResolve) === null || _a === void 0 ? void 0 : _a.call(this, false);\n              return;\n            }\n\n            selectionStart = anchorOffset || 0;\n            selectionEnd = focusOffset || 0;\n            textLength = ((_b = element.textContent) === null || _b === void 0 ? void 0 : _b.length) || 0;\n\n            if (anchorNode && focusNode) {\n              if (dom.nodeContains(element, anchorNode) && dom.nodeContains(element, focusNode)) {\n                if (anchorNode !== element) {\n                  let anchorFound = false;\n\n                  const addOffsets = node => {\n                    if (node === anchorNode) {\n                      anchorFound = true;\n                    } else if (node === focusNode) {\n                      return true;\n                    }\n\n                    const nodeText = node.textContent;\n\n                    if (nodeText && !dom.getFirstChild(node)) {\n                      const len = nodeText.length;\n\n                      if (anchorFound) {\n                        if (focusNode !== anchorNode) {\n                          selectionEnd += len;\n                        }\n                      } else {\n                        selectionStart += len;\n                        selectionEnd += len;\n                      }\n                    }\n\n                    let stop = false;\n\n                    for (let e = dom.getFirstChild(node); e && !stop; e = e.nextSibling) {\n                      stop = addOffsets(e);\n                    }\n\n                    return stop;\n                  };\n\n                  addOffsets(element);\n                }\n              }\n            }\n\n            (_c = this._ignoredInputResolve) === null || _c === void 0 ? void 0 : _c.call(this, true);\n          }, 0);\n        });\n      }\n\n      if (asyncRet && !(await asyncRet)) {\n        return true;\n      }\n\n      if (selectionStart !== selectionEnd) {\n        return true;\n      }\n\n      if (selectionStart > 0 && (keyCode === Keys.Left || keyCode === Keys.Up || keyCode === Keys.Home)) {\n        return true;\n      }\n\n      if (selectionStart < textLength && (keyCode === Keys.Right || keyCode === Keys.Down || keyCode === Keys.End)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction observeMutations(doc, tabster, updateTabsterByAttribute, syncState) {\n  if (typeof MutationObserver === \"undefined\") {\n    return () => {\n      /* Noop */\n    };\n  }\n\n  const getWindow = tabster.getWindow;\n  let elementByUId;\n\n  const onMutation = mutations => {\n    var _a, _b, _c, _d, _e;\n\n    for (const mutation of mutations) {\n      const target = mutation.target;\n      const removed = mutation.removedNodes;\n      const added = mutation.addedNodes;\n\n      if (mutation.type === \"attributes\") {\n        if (mutation.attributeName === TabsterAttributeName) {\n          updateTabsterByAttribute(tabster, target);\n        }\n      } else {\n        for (let i = 0; i < removed.length; i++) {\n          updateTabsterElements(removed[i], true);\n          (_b = (_a = tabster._dummyObserver).domChanged) === null || _b === void 0 ? void 0 : _b.call(_a, target);\n        }\n\n        for (let i = 0; i < added.length; i++) {\n          updateTabsterElements(added[i]);\n          (_d = (_c = tabster._dummyObserver).domChanged) === null || _d === void 0 ? void 0 : _d.call(_c, target);\n        }\n      }\n    }\n\n    (_e = tabster.modalizer) === null || _e === void 0 ? void 0 : _e.hiddenUpdate();\n  };\n\n  function updateTabsterElements(node, removed) {\n    if (!elementByUId) {\n      elementByUId = getInstanceContext(getWindow).elementByUId;\n    }\n\n    processNode(node, removed);\n    const walker = createElementTreeWalker(doc, node, element => {\n      return processNode(element, removed);\n    });\n\n    if (walker) {\n      while (walker.nextNode()) {\n        /* Iterating for the sake of calling processNode() callback. */\n      }\n    }\n  }\n\n  function processNode(element, removed) {\n    var _a;\n\n    if (!element.getAttribute) {\n      // It might actually be a text node.\n      return NodeFilter.FILTER_SKIP;\n    }\n\n    const uid = element.__tabsterElementUID;\n\n    if (uid && elementByUId) {\n      if (removed) {\n        delete elementByUId[uid];\n      } else {\n        (_a = elementByUId[uid]) !== null && _a !== void 0 ? _a : elementByUId[uid] = new WeakHTMLElement(getWindow, element);\n      }\n    }\n\n    if (getTabsterOnElement(tabster, element) || element.hasAttribute(TabsterAttributeName)) {\n      updateTabsterByAttribute(tabster, element, removed);\n    }\n\n    return NodeFilter.FILTER_SKIP;\n  }\n\n  const observer = dom.createMutationObserver(onMutation);\n\n  if (syncState) {\n    updateTabsterElements(getWindow().document.body);\n  }\n\n  observer.observe(doc, {\n    childList: true,\n    subtree: true,\n    attributes: true,\n    attributeFilter: [TabsterAttributeName]\n  });\n  return () => {\n    observer.disconnect();\n  };\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _conditionCheckTimeout = 100;\nclass ObservedElementAPI extends Subscribable {\n  constructor(tabster) {\n    super();\n    this._waiting = {};\n    this._lastRequestFocusId = 0;\n    this._observedById = {};\n    this._observedByName = {};\n    this._currentRequestTimestamp = 0;\n\n    this._onFocus = e => {\n      if (e) {\n        const current = this._currentRequest;\n\n        if (current) {\n          const delta = Date.now() - this._currentRequestTimestamp;\n\n          const settleTime = 300;\n\n          if (delta >= settleTime) {\n            // Giving some time for the focus to settle before\n            // automatically cancelling the current request on focus change.\n            delete this._currentRequest;\n            current.cancel();\n          }\n        }\n      }\n    };\n\n    this.onObservedElementUpdate = element => {\n      var _a;\n\n      const observed = (_a = getTabsterOnElement(this._tabster, element)) === null || _a === void 0 ? void 0 : _a.observed;\n      const uid = getElementUId(this._win, element);\n      let info = this._observedById[uid];\n\n      if (observed && documentContains(element.ownerDocument, element)) {\n        if (!info) {\n          info = this._observedById[uid] = {\n            element: new WeakHTMLElement(this._win, element)\n          };\n        }\n\n        observed.names.sort();\n        const observedNames = observed.names;\n        const prevNames = info.prevNames; // prevNames are already sorted\n\n        if (this._isObservedNamesUpdated(observedNames, prevNames)) {\n          if (prevNames) {\n            prevNames.forEach(prevName => {\n              const obn = this._observedByName[prevName];\n\n              if (obn && obn[uid]) {\n                if (Object.keys(obn).length > 1) {\n                  delete obn[uid];\n                } else {\n                  delete this._observedByName[prevName];\n                }\n              }\n            });\n          }\n\n          info.prevNames = observedNames;\n        }\n\n        observedNames.forEach(observedName => {\n          let obn = this._observedByName[observedName];\n\n          if (!obn) {\n            obn = this._observedByName[observedName] = {};\n          } // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n\n          obn[uid] = info;\n\n          this._waitConditional(observedName);\n        });\n      } else if (info) {\n        const prevNames = info.prevNames;\n\n        if (prevNames) {\n          prevNames.forEach(prevName => {\n            const obn = this._observedByName[prevName];\n\n            if (obn && obn[uid]) {\n              if (Object.keys(obn).length > 1) {\n                delete obn[uid];\n              } else {\n                delete this._observedByName[prevName];\n              }\n            }\n          });\n        }\n\n        delete this._observedById[uid];\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    tabster.queueInit(() => {\n      this._tabster.focusedElement.subscribe(this._onFocus);\n    });\n  }\n\n  dispose() {\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    for (const key of Object.keys(this._waiting)) {\n      this._rejectWaiting(key);\n    }\n\n    this._observedById = {};\n    this._observedByName = {};\n  }\n\n  _rejectWaiting(key, shouldResolve) {\n    const w = this._waiting[key];\n\n    if (w) {\n      const win = this._win();\n\n      if (w.timer) {\n        win.clearTimeout(w.timer);\n      }\n\n      if (w.conditionTimer) {\n        win.clearTimeout(w.conditionTimer);\n      }\n\n      if (!shouldResolve && w.reject) {\n        w.reject();\n      } else if (shouldResolve && w.resolve) {\n        w.resolve(null);\n      }\n\n      delete this._waiting[key];\n    }\n  }\n\n  _isObservedNamesUpdated(cur, prev) {\n    if (!prev || cur.length !== prev.length) {\n      return true;\n    }\n\n    for (let i = 0; i < cur.length; ++i) {\n      if (cur[i] !== prev[i]) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n  /**\r\n   * Returns existing element by observed name\r\n   *\r\n   * @param observedName An observed name\r\n   * @param accessibility Optionally, return only if the element is accessible or focusable\r\n   * @returns HTMLElement | null\r\n   */\n\n\n  getElement(observedName, accessibility) {\n    const o = this._observedByName[observedName];\n\n    if (o) {\n      for (const uid of Object.keys(o)) {\n        let el = o[uid].element.get() || null;\n\n        if (el) {\n          if (accessibility === ObservedElementAccesibilities.Accessible && !this._tabster.focusable.isAccessible(el) || accessibility === ObservedElementAccesibilities.Focusable && !this._tabster.focusable.isFocusable(el, true)) {\n            el = null;\n          }\n        } else {\n          delete o[uid];\n          delete this._observedById[uid];\n        }\n\n        return el;\n      }\n    }\n\n    return null;\n  }\n  /**\r\n   * Waits for the element to appear in the DOM and returns it.\r\n   *\r\n   * @param observedName An observed name\r\n   * @param timeout Wait no longer than this timeout\r\n   * @param accessibility Optionally, wait for the element to also become accessible or focusable before returning it\r\n   * @returns Promise<HTMLElement | null>\r\n   */\n\n\n  waitElement(observedName, timeout, accessibility) {\n    const el = this.getElement(observedName, accessibility);\n\n    if (el) {\n      return {\n        result: getPromise(this._win).resolve(el),\n        cancel: () => {\n          /**/\n        }\n      };\n    }\n\n    let prefix;\n\n    if (accessibility === ObservedElementAccesibilities.Accessible) {\n      prefix = \"a\";\n    } else if (accessibility === ObservedElementAccesibilities.Focusable) {\n      prefix = \"f\";\n    } else {\n      prefix = \"_\";\n    }\n\n    const key = prefix + observedName;\n    let w = this._waiting[key];\n\n    if (w && w.request) {\n      return w.request;\n    }\n\n    w = this._waiting[key] = {\n      timer: this._win().setTimeout(() => {\n        if (w.conditionTimer) {\n          this._win().clearTimeout(w.conditionTimer);\n        }\n\n        delete this._waiting[key];\n\n        if (w.resolve) {\n          w.resolve(null);\n        }\n      }, timeout)\n    };\n    const promise = new (getPromise(this._win))((resolve, reject) => {\n      w.resolve = resolve;\n      w.reject = reject;\n    });\n    w.request = {\n      result: promise,\n      cancel: () => {\n        this._rejectWaiting(key, true);\n      }\n    };\n\n    if (accessibility && this.getElement(observedName)) {\n      // If the observed element is alread in DOM, but not accessible yet,\n      // we need to run the wait logic.\n      this._waitConditional(observedName);\n    }\n\n    return w.request;\n  }\n\n  requestFocus(observedName, timeout) {\n    const requestId = ++this._lastRequestFocusId;\n    const currentRequestFocus = this._currentRequest;\n\n    if (currentRequestFocus) {\n      currentRequestFocus.cancel();\n    }\n\n    const request = this.waitElement(observedName, timeout, ObservedElementAccesibilities.Focusable);\n    this._currentRequest = request;\n    this._currentRequestTimestamp = Date.now();\n    request.result.finally(() => {\n      if (this._currentRequest === request) {\n        delete this._currentRequest;\n      }\n    });\n    return {\n      result: request.result.then(element => this._lastRequestFocusId === requestId && element ? this._tabster.focusedElement.focus(element, true) : false),\n      cancel: () => {\n        request.cancel();\n      }\n    };\n  }\n\n  _waitConditional(observedName) {\n    const waitingElementKey = \"_\" + observedName;\n    const waitingAccessibleElementKey = \"a\" + observedName;\n    const waitingFocusableElementKey = \"f\" + observedName;\n    const waitingElement = this._waiting[waitingElementKey];\n    const waitingAccessibleElement = this._waiting[waitingAccessibleElementKey];\n    const waitingFocusableElement = this._waiting[waitingFocusableElementKey];\n\n    const win = this._win();\n\n    const resolve = (element, key, waiting, accessibility) => {\n      var _a;\n\n      const observed = (_a = getTabsterOnElement(this._tabster, element)) === null || _a === void 0 ? void 0 : _a.observed;\n\n      if (!observed || !observed.names.includes(observedName)) {\n        return;\n      }\n\n      if (waiting.timer) {\n        win.clearTimeout(waiting.timer);\n      }\n\n      delete this._waiting[key];\n\n      if (waiting.resolve) {\n        waiting.resolve(element);\n      }\n\n      this.trigger(element, {\n        names: [observedName],\n        details: observed.details,\n        accessibility\n      });\n    };\n\n    if (waitingElement) {\n      const element = this.getElement(observedName);\n\n      if (element && documentContains(element.ownerDocument, element)) {\n        resolve(element, waitingElementKey, waitingElement, ObservedElementAccesibilities.Any);\n      }\n    }\n\n    if (waitingAccessibleElement && !waitingAccessibleElement.conditionTimer) {\n      const resolveAccessible = () => {\n        const element = this.getElement(observedName);\n\n        if (element && documentContains(element.ownerDocument, element) && this._tabster.focusable.isAccessible(element)) {\n          resolve(element, waitingAccessibleElementKey, waitingAccessibleElement, ObservedElementAccesibilities.Accessible);\n        } else {\n          waitingAccessibleElement.conditionTimer = win.setTimeout(resolveAccessible, _conditionCheckTimeout);\n        }\n      };\n\n      resolveAccessible();\n    }\n\n    if (waitingFocusableElement && !waitingFocusableElement.conditionTimer) {\n      const resolveFocusable = () => {\n        const element = this.getElement(observedName);\n\n        if (element && documentContains(element.ownerDocument, element) && this._tabster.focusable.isFocusable(element, true)) {\n          resolve(element, waitingFocusableElementKey, waitingFocusableElement, ObservedElementAccesibilities.Focusable);\n        } else {\n          waitingFocusableElement.conditionTimer = win.setTimeout(resolveFocusable, _conditionCheckTimeout);\n        }\n      };\n\n      resolveFocusable();\n    }\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst defaultProps = {\n  areaClass: \"tabster-focus-outline-area\",\n  outlineClass: \"tabster-focus-outline\",\n  outlineColor: \"#ff4500\",\n  outlineWidth: 2,\n  zIndex: 2147483647\n};\nlet _props = defaultProps;\n\nclass OutlinePosition {\n  constructor(left, top, right, bottom) {\n    this.left = left;\n    this.top = top;\n    this.right = right;\n    this.bottom = bottom;\n  }\n\n  equalsTo(other) {\n    return this.left === other.left && this.top === other.top && this.right === other.right && this.bottom === other.bottom;\n  }\n\n  clone() {\n    return new OutlinePosition(this.left, this.top, this.right, this.bottom);\n  }\n\n}\n\nclass OutlineAPI {\n  constructor(tabster) {\n    this._isVisible = false;\n    this._allOutlineElements = [];\n\n    this._init = () => {\n      this._tabster.keyboardNavigation.subscribe(this._onKeyboardNavigationStateChanged);\n\n      this._tabster.focusedElement.subscribe(this._onFocus);\n\n      const win = this._win();\n\n      win.addEventListener(\"scroll\", this._onScroll, true); // Capture!\n\n      if (this._fullScreenEventName) {\n        win.document.addEventListener(this._fullScreenEventName, this._onFullScreenChanged);\n      }\n    };\n\n    this._onFullScreenChanged = e => {\n      if (!this._fullScreenElementName || !e.target) {\n        return;\n      }\n\n      const target = e.target.body || e.target;\n\n      const outlineElements = this._getDOM(target);\n\n      if (target.ownerDocument && outlineElements) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const fsElement = target.ownerDocument[this._fullScreenElementName];\n\n        if (fsElement) {\n          fsElement.appendChild(outlineElements.container);\n          this._fullScreenElement = fsElement;\n        } else {\n          target.ownerDocument.body.appendChild(outlineElements.container);\n          this._fullScreenElement = undefined;\n        }\n      }\n    };\n\n    this._onKeyboardNavigationStateChanged = () => {\n      this._onFocus(this._tabster.focusedElement.getFocusedElement());\n    };\n\n    this._onFocus = e => {\n      if (!this._updateElement(e) && this._isVisible) {\n        this._setVisibility(false);\n      }\n    };\n\n    this._onScroll = e => {\n      if (!this._outlinedElement || !OutlineAPI._isParentChild(e.target, this._outlinedElement)) {\n        return;\n      }\n\n      this._curPos = undefined;\n\n      this._setOutlinePosition();\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    tabster.queueInit(this._init);\n\n    if (typeof document !== \"undefined\") {\n      if (\"onfullscreenchange\" in document) {\n        this._fullScreenEventName = \"fullscreenchange\";\n        this._fullScreenElementName = \"fullscreenElement\";\n      } else if (\"onwebkitfullscreenchange\" in document) {\n        this._fullScreenEventName = \"webkitfullscreenchange\";\n        this._fullScreenElementName = \"webkitFullscreenElement\";\n      } else if (\"onmozfullscreenchange\" in document) {\n        this._fullScreenEventName = \"mozfullscreenchange\";\n        this._fullScreenElementName = \"mozFullScreenElement\";\n      } else if (\"onmsfullscreenchange\" in document) {\n        this._fullScreenEventName = \"msfullscreenchange\";\n        this._fullScreenElementName = \"msFullscreenElement\";\n      }\n    }\n  }\n\n  setup(props) {\n    _props = { ..._props,\n      ...props\n    };\n\n    const win = this._win();\n\n    if (!win.__tabsterOutline) {\n      win.__tabsterOutline = {};\n    }\n\n    if (!win.__tabsterOutline.style) {\n      win.__tabsterOutline.style = appendStyles(win.document, _props);\n    }\n\n    if (!props || !props.areaClass) {\n      win.document.body.classList.add(defaultProps.areaClass);\n    } else {\n      win.document.body.classList.remove(defaultProps.areaClass);\n    }\n  }\n\n  dispose() {\n    const win = this._win();\n\n    if (this._updateTimer) {\n      win.clearTimeout(this._updateTimer);\n      this._updateTimer = undefined;\n    }\n\n    this._tabster.keyboardNavigation.unsubscribe(this._onKeyboardNavigationStateChanged);\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    win.removeEventListener(\"scroll\", this._onScroll, true);\n\n    if (this._fullScreenEventName) {\n      win.document.removeEventListener(this._fullScreenEventName, this._onFullScreenChanged);\n    }\n\n    this._allOutlineElements.forEach(outlineElements => this._removeDOM(outlineElements.container));\n\n    this._allOutlineElements = [];\n    delete this._outlinedElement;\n    delete this._curPos;\n    delete this._curOutlineElements;\n    delete this._fullScreenElement;\n  }\n\n  _shouldShowCustomOutline(element) {\n    const tabsterOnElement = getTabsterOnElement(this._tabster, element);\n\n    if (tabsterOnElement && tabsterOnElement.outline && tabsterOnElement.outline.isIgnored) {\n      return false;\n    }\n\n    for (let i = element; i; i = i.parentElement) {\n      if (i.classList && i.classList.contains(_props.areaClass)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  _updateElement(e) {\n    this._outlinedElement = undefined;\n\n    if (this._updateTimer) {\n      this._win().clearTimeout(this._updateTimer);\n\n      this._updateTimer = undefined;\n    }\n\n    this._curPos = undefined;\n\n    if (!this._tabster.keyboardNavigation.isNavigatingWithKeyboard()) {\n      return false;\n    }\n\n    if (e) {\n      // TODO: It's hard (and not necessary) to come up with every possible\n      // condition when there should be no outline, it's better to add an\n      // API to customize the ignores.\n      if (e.tagName === \"INPUT\") {\n        const inputType = e.type;\n        const outlinedInputTypes = {\n          button: true,\n          checkbox: true,\n          file: true,\n          image: true,\n          radio: true,\n          range: true,\n          reset: true,\n          submit: true\n        };\n\n        if (!(inputType in outlinedInputTypes)) {\n          return false;\n        }\n      } else if (e.tagName === \"TEXTAREA\" || e.contentEditable === \"true\" || e.tagName === \"IFRAME\") {\n        return false;\n      }\n\n      if (!this._shouldShowCustomOutline(e)) {\n        return false;\n      }\n\n      if (this._tabster.keyboardNavigation.isNavigatingWithKeyboard()) {\n        this._outlinedElement = e;\n\n        this._updateOutline();\n      }\n\n      return true;\n    }\n\n    return false;\n  }\n\n  _updateOutline() {\n    this._setOutlinePosition();\n\n    if (this._updateTimer) {\n      this._win().clearTimeout(this._updateTimer);\n\n      this._updateTimer = undefined;\n    }\n\n    if (!this._outlinedElement) {\n      return;\n    }\n\n    this._updateTimer = this._win().setTimeout(() => {\n      this._updateTimer = undefined;\n\n      this._updateOutline();\n    }, 30);\n  }\n\n  _setVisibility(visible) {\n    this._isVisible = visible;\n\n    if (this._curOutlineElements) {\n      if (visible) {\n        this._curOutlineElements.container.classList.add(`${_props.outlineClass}_visible`);\n      } else {\n        this._curOutlineElements.container.classList.remove(`${_props.outlineClass}_visible`);\n\n        this._curPos = undefined;\n      }\n    }\n  }\n\n  _setOutlinePosition() {\n    if (!this._outlinedElement) {\n      return;\n    }\n\n    let boundingRect = getBoundingRect(this._win, this._outlinedElement);\n    const position = new OutlinePosition(boundingRect.left, boundingRect.top, boundingRect.right, boundingRect.bottom);\n\n    if (this._curPos && position.equalsTo(this._curPos)) {\n      return;\n    }\n\n    const outlineElements = this._getDOM(this._outlinedElement);\n\n    const win = this._outlinedElement.ownerDocument && this._outlinedElement.ownerDocument.defaultView;\n\n    if (!outlineElements || !win) {\n      return;\n    }\n\n    if (this._curOutlineElements !== outlineElements) {\n      this._setVisibility(false);\n\n      this._curOutlineElements = outlineElements;\n    }\n\n    this._curPos = position;\n    const p = position.clone();\n    let hasAbsolutePositionedParent = false;\n    let hasFixedPositionedParent = false;\n    const container = outlineElements.container;\n    const scrollingElement = container && container.ownerDocument && container.ownerDocument.scrollingElement;\n\n    if (!scrollingElement) {\n      return;\n    }\n\n    for (let parent = this._outlinedElement.parentElement; parent && parent.nodeType === Node.ELEMENT_NODE; parent = parent.parentElement) {\n      // The element might be partially visible within its scrollable parent,\n      // reduce the bounding rect if this is the case.\n      if (parent === this._fullScreenElement) {\n        break;\n      }\n\n      boundingRect = getBoundingRect(this._win, parent);\n      const win = parent.ownerDocument && parent.ownerDocument.defaultView;\n\n      if (!win) {\n        return;\n      }\n\n      const computedStyle = win.getComputedStyle(parent);\n      const position = computedStyle.position;\n\n      if (position === \"absolute\") {\n        hasAbsolutePositionedParent = true;\n      } else if (position === \"fixed\" || position === \"sticky\") {\n        hasFixedPositionedParent = true;\n      }\n\n      if (computedStyle.overflow === \"visible\") {\n        continue;\n      }\n\n      if (!hasAbsolutePositionedParent && !hasFixedPositionedParent || computedStyle.overflow === \"hidden\") {\n        if (boundingRect.left > p.left) {\n          p.left = boundingRect.left;\n        }\n\n        if (boundingRect.top > p.top) {\n          p.top = boundingRect.top;\n        }\n\n        if (boundingRect.right < p.right) {\n          p.right = boundingRect.right;\n        }\n\n        if (boundingRect.bottom < p.bottom) {\n          p.bottom = boundingRect.bottom;\n        }\n      }\n    }\n\n    const allRect = getBoundingRect(this._win, scrollingElement);\n    const allWidth = allRect.left + allRect.right;\n    const allHeight = allRect.top + allRect.bottom;\n    const ow = _props.outlineWidth;\n    p.left = p.left > ow ? p.left - ow : 0;\n    p.top = p.top > ow ? p.top - ow : 0;\n    p.right = p.right < allWidth - ow ? p.right + ow : allWidth;\n    p.bottom = p.bottom < allHeight - ow ? p.bottom + ow : allHeight;\n    const width = p.right - p.left;\n    const height = p.bottom - p.top;\n\n    if (width > ow * 2 && height > ow * 2) {\n      const leftBorderNode = outlineElements.left;\n      const topBorderNode = outlineElements.top;\n      const rightBorderNode = outlineElements.right;\n      const bottomBorderNode = outlineElements.bottom;\n      const sx = this._fullScreenElement || hasFixedPositionedParent ? 0 : win.pageXOffset;\n      const sy = this._fullScreenElement || hasFixedPositionedParent ? 0 : win.pageYOffset;\n      container.style.position = hasFixedPositionedParent ? \"fixed\" : \"absolute\";\n      container.style.background = _props.outlineColor;\n      leftBorderNode.style.width = rightBorderNode.style.width = topBorderNode.style.height = bottomBorderNode.style.height = _props.outlineWidth + \"px\";\n      leftBorderNode.style.left = topBorderNode.style.left = bottomBorderNode.style.left = p.left + sx + \"px\";\n      rightBorderNode.style.left = p.left + sx + width - ow + \"px\";\n      leftBorderNode.style.top = rightBorderNode.style.top = topBorderNode.style.top = p.top + sy + \"px\";\n      bottomBorderNode.style.top = p.top + sy + height - ow + \"px\";\n      leftBorderNode.style.height = rightBorderNode.style.height = height + \"px\";\n      topBorderNode.style.width = bottomBorderNode.style.width = width + \"px\";\n\n      this._setVisibility(true);\n    } else {\n      this._setVisibility(false);\n    }\n  }\n\n  _getDOM(contextElement) {\n    const doc = contextElement.ownerDocument;\n    const win = doc && doc.defaultView;\n\n    if (!doc || !win || !win.__tabsterOutline) {\n      return undefined;\n    }\n\n    if (!win.__tabsterOutline.style) {\n      win.__tabsterOutline.style = appendStyles(doc, _props);\n    }\n\n    if (!win.__tabsterOutline.elements) {\n      const outlineElements = {\n        container: doc.createElement(\"div\"),\n        left: doc.createElement(\"div\"),\n        top: doc.createElement(\"div\"),\n        right: doc.createElement(\"div\"),\n        bottom: doc.createElement(\"div\")\n      };\n      outlineElements.container.className = _props.outlineClass;\n      outlineElements.left.className = `${_props.outlineClass}__left`;\n      outlineElements.top.className = `${_props.outlineClass}__top`;\n      outlineElements.right.className = `${_props.outlineClass}__right`;\n      outlineElements.bottom.className = `${_props.outlineClass}__bottom`;\n      outlineElements.container.appendChild(outlineElements.left);\n      outlineElements.container.appendChild(outlineElements.top);\n      outlineElements.container.appendChild(outlineElements.right);\n      outlineElements.container.appendChild(outlineElements.bottom);\n      doc.body.appendChild(outlineElements.container);\n      win.__tabsterOutline.elements = outlineElements; // TODO: Make a garbage collector to remove the references\n      // to the outlines which are nowhere in the DOM anymore.\n\n      this._allOutlineElements.push(outlineElements);\n    }\n\n    return win.__tabsterOutline.elements;\n  }\n\n  _removeDOM(contextElement) {\n    const win = contextElement.ownerDocument && contextElement.ownerDocument.defaultView;\n    const outline = win && win.__tabsterOutline;\n\n    if (!outline) {\n      return;\n    }\n\n    if (outline.style && outline.style.parentNode) {\n      outline.style.parentNode.removeChild(outline.style);\n      delete outline.style;\n    }\n\n    const outlineElements = outline && outline.elements;\n\n    if (outlineElements) {\n      if (outlineElements.container.parentNode) {\n        outlineElements.container.parentNode.removeChild(outlineElements.container);\n      }\n\n      delete outline.elements;\n    }\n  }\n\n  static _isParentChild(parent, child) {\n    return child === parent || // tslint:disable-next-line:no-bitwise\n    !!(parent.compareDocumentPosition(child) & document.DOCUMENT_POSITION_CONTAINED_BY);\n  }\n\n}\n\nfunction appendStyles(document, props) {\n  const style = document.createElement(\"style\");\n  style.type = \"text/css\";\n  style.appendChild(document.createTextNode(getOutlineStyles(props)));\n  document.head.appendChild(style);\n  return style;\n}\n\nfunction getOutlineStyles(props) {\n  return `\n.${props.areaClass} *, .${props.areaClass} *:focus {\noutline: none !important;\n}\n\n.${props.outlineClass} {\ndisplay: none;\nposition: absolute;\nwidth: 0;\nheight: 0;\nleft: 0;\ntop: 0;\nz-index: ${props.zIndex};\n}\n\n.${props.outlineClass}.${props.outlineClass}_visible {\ndisplay: block;\n}\n\n.${props.outlineClass}__left,\n.${props.outlineClass}__top,\n.${props.outlineClass}__right,\n.${props.outlineClass}__bottom {\nposition: absolute;\nbackground: inherit;\n}`;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\n/**\r\n * Allows default or user focus behaviour on the DOM subtree\r\n * i.e. Tabster will not control focus events within an uncontrolled area\r\n */\nclass UncontrolledAPI {\n  constructor(isUncontrolledCompletely) {\n    this._isUncontrolledCompletely = isUncontrolledCompletely;\n  }\n\n  isUncontrolledCompletely(element, completely) {\n    var _a;\n\n    const isUncontrolledCompletely = (_a = this._isUncontrolledCompletely) === null || _a === void 0 ? void 0 : _a.call(this, element, completely); // If isUncontrolledCompletely callback is not defined or returns undefined, then the default\n    // behaviour is to return the uncontrolled.completely value from the element.\n\n    return isUncontrolledCompletely === undefined ? completely : isUncontrolledCompletely;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst EVENT_NAME = \"restorer:restorefocus\";\nconst HISOTRY_DEPTH = 10;\n\nclass Restorer extends TabsterPart {\n  constructor(tabster, element, props) {\n    var _a;\n\n    super(tabster, element, props);\n    this._hasFocus = false;\n\n    this._onFocusOut = e => {\n      var _a;\n\n      const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n\n      if (element && e.relatedTarget === null) {\n        triggerEvent(element, EVENT_NAME);\n      }\n\n      if (element && !dom.nodeContains(element, e.relatedTarget)) {\n        this._hasFocus = false;\n      }\n    };\n\n    this._onFocusIn = () => {\n      this._hasFocus = true;\n    };\n\n    if (this._props.type === RestorerTypes.Source) {\n      const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n      element === null || element === void 0 ? void 0 : element.addEventListener(\"focusout\", this._onFocusOut);\n      element === null || element === void 0 ? void 0 : element.addEventListener(\"focusin\", this._onFocusIn); // set hasFocus when the instance is created, in case focus has already moved within it\n\n      this._hasFocus = dom.nodeContains(element, element && dom.getActiveElement(element.ownerDocument));\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    if (this._props.type === RestorerTypes.Source) {\n      const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n      element === null || element === void 0 ? void 0 : element.removeEventListener(\"focusout\", this._onFocusOut);\n      element === null || element === void 0 ? void 0 : element.removeEventListener(\"focusin\", this._onFocusIn);\n\n      if (this._hasFocus) {\n        const doc = this._tabster.getWindow().document;\n\n        triggerEvent(doc.body, EVENT_NAME);\n      }\n    }\n  }\n\n}\n\nclass RestorerAPI {\n  constructor(tabster) {\n    this._history = [];\n    this._restoreFocusTimeout = 0;\n\n    this._onRestoreFocus = e => {\n      const win = this._getWindow();\n\n      if (this._restoreFocusTimeout) {\n        win.clearTimeout(this._restoreFocusTimeout);\n        this._restoreFocusTimeout = 0;\n      } // ShadowDOM will have shadowRoot as e.target.\n\n\n      const target = e.composedPath()[0];\n\n      if (target) {\n        this._restoreFocusTimeout = win.setTimeout(() => this._restoreFocus(target));\n      }\n    };\n\n    this._onFocusIn = element => {\n      var _a;\n\n      if (!element) {\n        return;\n      }\n\n      const tabsterAttribute = getTabsterOnElement(this._tabster, element);\n\n      if (((_a = tabsterAttribute === null || tabsterAttribute === void 0 ? void 0 : tabsterAttribute.restorer) === null || _a === void 0 ? void 0 : _a.getProps().type) !== RestorerTypes.Target) {\n        return;\n      }\n\n      this._addToHistory(element);\n    };\n\n    this._restoreFocus = source => {\n      var _a; // don't restore focus if focus isn't lost to body\n\n\n      const doc = this._getWindow().document;\n\n      if (dom.getActiveElement(doc) !== doc.body) {\n        return;\n      }\n\n      if ( // clicking on any empty space focuses body - this is can be a false positive\n      !this._keyboardNavState.isNavigatingWithKeyboard() && // Source no longer exists on DOM - always restore focus\n      dom.nodeContains(doc.body, source)) {\n        return;\n      }\n\n      let weakElement = this._history.pop();\n\n      while (weakElement && !dom.nodeContains(doc.body, dom.getParentElement(weakElement.get()))) {\n        weakElement = this._history.pop();\n      }\n\n      (_a = weakElement === null || weakElement === void 0 ? void 0 : weakElement.get()) === null || _a === void 0 ? void 0 : _a.focus();\n    };\n\n    this._tabster = tabster;\n    this._getWindow = tabster.getWindow;\n\n    this._getWindow().addEventListener(EVENT_NAME, this._onRestoreFocus);\n\n    this._keyboardNavState = tabster.keyboardNavigation;\n    this._focusedElementState = tabster.focusedElement;\n\n    this._focusedElementState.subscribe(this._onFocusIn);\n  }\n\n  dispose() {\n    const win = this._getWindow();\n\n    this._focusedElementState.unsubscribe(this._onFocusIn);\n\n    win.removeEventListener(EVENT_NAME, this._onRestoreFocus);\n\n    if (this._restoreFocusTimeout) {\n      win.clearTimeout(this._restoreFocusTimeout);\n    }\n  }\n\n  _addToHistory(element) {\n    var _a; // Don't duplicate the top of history\n\n\n    if (((_a = this._history[this._history.length - 1]) === null || _a === void 0 ? void 0 : _a.get()) === element) {\n      return;\n    }\n\n    if (this._history.length > HISOTRY_DEPTH) {\n      this._history.shift();\n    }\n\n    this._history.push(new WeakHTMLElement(this._getWindow, element));\n  }\n\n  createRestorer(element, props) {\n    const restorer = new Restorer(this._tabster, element, props); // Focus might already be on a restorer target when it gets created so the focusin will not do anything\n\n    if (props.type === RestorerTypes.Target && dom.getActiveElement(element.ownerDocument) === element) {\n      this._addToHistory(element);\n    }\n\n    return restorer;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction getActiveElement(doc) {\n  var _a;\n\n  let activeElement = doc.activeElement;\n\n  while ((_a = activeElement === null || activeElement === void 0 ? void 0 : activeElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement) {\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n\n  return activeElement;\n}\nfunction nodeContains(node, otherNode) {\n  var _a, _b;\n\n  if (!node || !otherNode) {\n    return false;\n  }\n\n  let currentNode = otherNode;\n\n  while (currentNode) {\n    if (currentNode === node) {\n      return true;\n    }\n\n    if (typeof currentNode.assignedElements !== \"function\" && ((_a = currentNode.assignedSlot) === null || _a === void 0 ? void 0 : _a.parentNode)) {\n      // Element is slotted\n      currentNode = (_b = currentNode.assignedSlot) === null || _b === void 0 ? void 0 : _b.parentNode;\n    } else if (currentNode.nodeType === document.DOCUMENT_FRAGMENT_NODE) {\n      // Element is in shadow root\n      currentNode = currentNode.host;\n    } else {\n      currentNode = currentNode.parentNode;\n    }\n  }\n\n  return false;\n}\nfunction getParentNode(node) {\n  if (!node) {\n    return null;\n  }\n\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && node.host) {\n    return node.host;\n  }\n\n  return node.parentNode;\n}\nfunction getParentElement(element) {\n  for (let parentNode = getParentNode(element); parentNode; parentNode = getParentNode(parentNode)) {\n    if (parentNode.nodeType === Node.ELEMENT_NODE) {\n      return parentNode;\n    }\n  }\n\n  return null;\n}\nfunction getFirstChild(node) {\n  if (!node) {\n    return null;\n  }\n\n  if (node.shadowRoot) {\n    const child = getFirstChild(node.shadowRoot);\n\n    if (child) {\n      return child;\n    } // If the attached shadowRoot has no children, just try ordinary children,\n    // that might come after.\n\n  }\n\n  return node.firstChild;\n}\nfunction getLastChild$1(node) {\n  if (!node) {\n    return null;\n  }\n\n  if (!node.lastChild && node.shadowRoot) {\n    return getLastChild$1(node.shadowRoot);\n  }\n\n  return node.lastChild;\n}\nfunction getNextSibling(node) {\n  return (node === null || node === void 0 ? void 0 : node.nextSibling) || null;\n}\nfunction getPreviousSibling(node) {\n  var _a;\n\n  if (!node) {\n    return null;\n  }\n\n  let sibling = node.previousSibling;\n\n  if (!sibling && ((_a = node.parentElement) === null || _a === void 0 ? void 0 : _a.shadowRoot)) {\n    sibling = getLastChild$1(node.parentElement.shadowRoot);\n  }\n\n  return sibling;\n}\nfunction getFirstElementChild(element) {\n  let child = getFirstChild(element);\n\n  while (child && child.nodeType !== Node.ELEMENT_NODE) {\n    child = getNextSibling(child);\n  }\n\n  return child;\n}\nfunction getLastElementChild(element) {\n  let child = getLastChild$1(element);\n\n  while (child && child.nodeType !== Node.ELEMENT_NODE) {\n    child = getPreviousSibling(child);\n  }\n\n  return child;\n}\nfunction getNextElementSibling(element) {\n  let sibling = getNextSibling(element);\n\n  while (sibling && sibling.nodeType !== Node.ELEMENT_NODE) {\n    sibling = getNextSibling(sibling);\n  }\n\n  return sibling;\n}\nfunction getPreviousElementSibling(element) {\n  let sibling = getPreviousSibling(element);\n\n  while (sibling && sibling.nodeType !== Node.ELEMENT_NODE) {\n    sibling = getPreviousSibling(sibling);\n  }\n\n  return sibling;\n}\nfunction appendChild(parent, child) {\n  const shadowRoot = parent.shadowRoot;\n  return shadowRoot ? shadowRoot.appendChild(child) : parent.appendChild(child);\n}\nfunction insertBefore(parent, child, referenceChild) {\n  const shadowRoot = parent.shadowRoot;\n  return shadowRoot ? shadowRoot.insertBefore(child, referenceChild) : parent.insertBefore(child, referenceChild);\n}\nfunction getSelection(ref) {\n  var _a;\n\n  const win = (_a = ref.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView;\n\n  if (!win) {\n    return null;\n  }\n\n  for (let el = ref; el; el = el.parentNode) {\n    if (el.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n      const tmp = el; // ShadowRoot.getSelection() exists only in Chrome.\n\n      if (tmp.getSelection) {\n        return tmp.getSelection() || null;\n      }\n\n      break;\n    }\n  }\n\n  return win.getSelection() || null;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nfunction getLastChild(container) {\n  let lastChild = null;\n\n  for (let i = getLastElementChild(container); i; i = getLastElementChild(i)) {\n    lastChild = i;\n  }\n\n  return lastChild || undefined;\n}\n\nclass ShadowTreeWalker {\n  constructor(doc, root, whatToShow, filter) {\n    this._walkerStack = [];\n    this._currentSetFor = new Set();\n\n    this._acceptNode = node => {\n      var _a;\n\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        const shadowRoot = node.shadowRoot;\n\n        if (shadowRoot) {\n          const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, {\n            acceptNode: this._acceptNode\n          });\n\n          this._walkerStack.unshift(walker);\n\n          return NodeFilter.FILTER_ACCEPT;\n        } else {\n          if (typeof this.filter === \"function\") {\n            return this.filter(node);\n          } else if ((_a = this.filter) === null || _a === void 0 ? void 0 : _a.acceptNode) {\n            return this.filter.acceptNode(node);\n          }\n        }\n      }\n\n      return NodeFilter.FILTER_SKIP;\n    };\n\n    this._doc = doc;\n    this.root = root;\n    this.filter = filter !== null && filter !== void 0 ? filter : null;\n    this.whatToShow = whatToShow !== null && whatToShow !== void 0 ? whatToShow : NodeFilter.SHOW_ALL;\n    this._currentNode = root;\n\n    this._walkerStack.unshift(doc.createTreeWalker(root, whatToShow, this._acceptNode));\n\n    const shadowRoot = root.shadowRoot;\n\n    if (shadowRoot) {\n      const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, {\n        acceptNode: this._acceptNode\n      });\n\n      this._walkerStack.unshift(walker);\n    }\n  }\n\n  get currentNode() {\n    return this._currentNode;\n  }\n\n  set currentNode(node) {\n    if (!nodeContains(this.root, node)) {\n      throw new Error(\"Cannot set currentNode to a node that is not contained by the root node.\");\n    }\n\n    const walkers = [];\n    let curNode = node;\n    let currentWalkerCurrentNode = node;\n    this._currentNode = node;\n\n    while (curNode && curNode !== this.root) {\n      if (curNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n        const shadowRoot = curNode;\n\n        const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, {\n          acceptNode: this._acceptNode\n        });\n\n        walkers.push(walker);\n        walker.currentNode = currentWalkerCurrentNode;\n\n        this._currentSetFor.add(walker);\n\n        curNode = currentWalkerCurrentNode = shadowRoot.host;\n      } else {\n        curNode = curNode.parentNode;\n      }\n    }\n\n    const walker = this._doc.createTreeWalker(this.root, this.whatToShow, {\n      acceptNode: this._acceptNode\n    });\n\n    walkers.push(walker);\n    walker.currentNode = currentWalkerCurrentNode;\n\n    this._currentSetFor.add(walker);\n\n    this._walkerStack = walkers;\n  }\n\n  firstChild() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  lastChild() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  nextNode() {\n    var _a;\n\n    const nextNode = this._walkerStack[0].nextNode();\n\n    if (nextNode) {\n      const shadowRoot = nextNode.shadowRoot;\n\n      if (shadowRoot) {\n        let nodeResult;\n\n        if (typeof this.filter === \"function\") {\n          nodeResult = this.filter(nextNode);\n        } else if ((_a = this.filter) === null || _a === void 0 ? void 0 : _a.acceptNode) {\n          nodeResult = this.filter.acceptNode(nextNode);\n        }\n\n        if (nodeResult === NodeFilter.FILTER_ACCEPT) {\n          return nextNode;\n        } // _acceptNode should have added new walker for this shadow,\n        // go in recursively.\n\n\n        return this.nextNode();\n      }\n\n      return nextNode;\n    } else {\n      if (this._walkerStack.length > 1) {\n        this._walkerStack.shift();\n\n        return this.nextNode();\n      } else {\n        return null;\n      }\n    }\n  }\n\n  previousNode() {\n    var _a, _b;\n\n    const currentWalker = this._walkerStack[0];\n\n    if (currentWalker.currentNode === currentWalker.root) {\n      if (this._currentSetFor.has(currentWalker)) {\n        this._currentSetFor.delete(currentWalker);\n\n        if (this._walkerStack.length > 1) {\n          this._walkerStack.shift();\n\n          return this.previousNode();\n        } else {\n          return null;\n        }\n      }\n\n      const lastChild = getLastChild(currentWalker.root);\n\n      if (lastChild) {\n        currentWalker.currentNode = lastChild;\n        let nodeResult;\n\n        if (typeof this.filter === \"function\") {\n          nodeResult = this.filter(lastChild);\n        } else if ((_a = this.filter) === null || _a === void 0 ? void 0 : _a.acceptNode) {\n          nodeResult = this.filter.acceptNode(lastChild);\n        }\n\n        if (nodeResult === NodeFilter.FILTER_ACCEPT) {\n          return lastChild;\n        }\n      }\n    }\n\n    const previousNode = currentWalker.previousNode();\n\n    if (previousNode) {\n      const shadowRoot = previousNode.shadowRoot;\n\n      if (shadowRoot) {\n        let nodeResult;\n\n        if (typeof this.filter === \"function\") {\n          nodeResult = this.filter(previousNode);\n        } else if ((_b = this.filter) === null || _b === void 0 ? void 0 : _b.acceptNode) {\n          nodeResult = this.filter.acceptNode(previousNode);\n        }\n\n        if (nodeResult === NodeFilter.FILTER_ACCEPT) {\n          return previousNode;\n        } // _acceptNode should have added new walker for this shadow,\n        // go in recursively.\n\n\n        return this.previousNode();\n      }\n\n      return previousNode;\n    } else {\n      if (this._walkerStack.length > 1) {\n        this._walkerStack.shift();\n\n        return this.previousNode();\n      } else {\n        return null;\n      }\n    }\n  }\n\n  nextSibling() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  previousSibling() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  parentNode() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n}\nfunction createShadowTreeWalker(doc, root, whatToShow, filter) {\n  return new ShadowTreeWalker(doc, root, whatToShow, filter);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass ShadowMutationObserver {\n  static _overrideAttachShadow(win) {\n    const origAttachShadow = win.Element.prototype.attachShadow;\n\n    if (origAttachShadow.__origAttachShadow) {\n      return;\n    }\n\n    Element.prototype.attachShadow = function (options) {\n      const shadowRoot = origAttachShadow.call(this, options);\n\n      for (const shadowObserver of ShadowMutationObserver._shadowObservers) {\n        shadowObserver._addSubObserver(shadowRoot);\n      }\n\n      return shadowRoot;\n    };\n\n    Element.prototype.attachShadow.__origAttachShadow = origAttachShadow;\n  }\n\n  constructor(callback) {\n    this._isObserving = false;\n\n    this._callbackWrapper = (mutations, observer) => {\n      for (const mutation of mutations) {\n        if (mutation.type === \"childList\") {\n          const removed = mutation.removedNodes;\n          const added = mutation.addedNodes;\n\n          for (let i = 0; i < removed.length; i++) {\n            this._walkShadows(removed[i], true);\n          }\n\n          for (let i = 0; i < added.length; i++) {\n            this._walkShadows(added[i]);\n          }\n        }\n      }\n\n      this._callback(mutations, observer);\n    };\n\n    this._callback = callback;\n    this._observer = new MutationObserver(this._callbackWrapper);\n    this._subObservers = new Map();\n  }\n\n  _addSubObserver(shadowRoot) {\n    if (!this._options || !this._callback || this._subObservers.has(shadowRoot)) {\n      return;\n    }\n\n    if (this._options.subtree && nodeContains(this._root, shadowRoot)) {\n      const subObserver = new MutationObserver(this._callbackWrapper);\n\n      this._subObservers.set(shadowRoot, subObserver);\n\n      if (this._isObserving) {\n        subObserver.observe(shadowRoot, this._options);\n      }\n\n      this._walkShadows(shadowRoot);\n    }\n  }\n\n  disconnect() {\n    this._isObserving = false;\n    delete this._options;\n\n    ShadowMutationObserver._shadowObservers.delete(this);\n\n    for (const subObserver of this._subObservers.values()) {\n      subObserver.disconnect();\n    }\n\n    this._subObservers.clear();\n\n    this._observer.disconnect();\n  }\n\n  observe(target, options) {\n    const doc = target.nodeType === Node.DOCUMENT_NODE ? target : target.ownerDocument;\n    const win = doc === null || doc === void 0 ? void 0 : doc.defaultView;\n\n    if (!doc || !win) {\n      return;\n    }\n\n    ShadowMutationObserver._overrideAttachShadow(win);\n\n    ShadowMutationObserver._shadowObservers.add(this);\n\n    this._root = target;\n    this._options = options;\n    this._isObserving = true;\n\n    this._observer.observe(target, options);\n\n    this._walkShadows(target);\n  }\n\n  _walkShadows(target, remove) {\n    const doc = target.nodeType === Node.DOCUMENT_NODE ? target : target.ownerDocument;\n\n    if (!doc) {\n      return;\n    }\n\n    if (target === doc) {\n      target = doc.body;\n    } else {\n      const shadowRoot = target.shadowRoot;\n\n      if (shadowRoot) {\n        this._addSubObserver(shadowRoot);\n\n        return;\n      }\n    }\n\n    const walker = doc.createTreeWalker(target, NodeFilter.SHOW_ELEMENT, {\n      acceptNode: node => {\n        if (node.nodeType === Node.ELEMENT_NODE) {\n          if (remove) {\n            const subObserver = this._subObservers.get(node);\n\n            if (subObserver) {\n              subObserver.disconnect();\n\n              this._subObservers.delete(node);\n            }\n          } else {\n            const shadowRoot = node.shadowRoot;\n\n            if (shadowRoot) {\n              this._addSubObserver(shadowRoot);\n            }\n          }\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      }\n    });\n    walker.nextNode();\n  }\n\n  takeRecords() {\n    const records = this._observer.takeRecords();\n\n    for (const subObserver of this._subObservers.values()) {\n      records.push(...subObserver.takeRecords());\n    }\n\n    return records;\n  }\n\n}\nShadowMutationObserver._shadowObservers = /*#__PURE__*/new Set();\nfunction createShadowMutationObserver(callback) {\n  return new ShadowMutationObserver(callback);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction shadowQuerySelector(node, selector, all) {\n  // TODO: This is probably slow. Optimize to use each shadowRoot's querySelector/querySelectorAll\n  //       instead of walking the tree.\n  const elements = [];\n  walk(node, selector);\n  return elements;\n\n  function walk(from, selector) {\n    let el = null;\n    const walker = document.createTreeWalker(from, NodeFilter.SHOW_ELEMENT, {\n      acceptNode: n => {\n        if (n.nodeType === Node.ELEMENT_NODE) {\n          if (n.matches(selector)) {\n            el = n;\n            elements.push(el);\n            return all ? NodeFilter.FILTER_SKIP : NodeFilter.FILTER_ACCEPT;\n          }\n\n          const shadowRoot = n.shadowRoot;\n\n          if (shadowRoot) {\n            walk(shadowRoot, selector);\n            return !all && elements.length ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n          }\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      }\n    });\n    walker.nextNode();\n  }\n}\n\nfunction querySelectorAll(node, selector) {\n  return shadowQuerySelector(node, selector, true);\n}\nfunction querySelector(node, selector) {\n  return shadowQuerySelector(node, selector, false)[0] || null;\n}\nfunction getElementById(doc, id) {\n  return querySelector(doc, \"#\" + id);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nvar shadowDOMAPI = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    createTreeWalker: createShadowTreeWalker,\n    createMutationObserver: createShadowMutationObserver,\n    appendChild: appendChild,\n    getActiveElement: getActiveElement,\n    getFirstChild: getFirstChild,\n    getFirstElementChild: getFirstElementChild,\n    getLastChild: getLastChild$1,\n    getLastElementChild: getLastElementChild,\n    getNextElementSibling: getNextElementSibling,\n    getNextSibling: getNextSibling,\n    getParentElement: getParentElement,\n    getParentNode: getParentNode,\n    getPreviousElementSibling: getPreviousElementSibling,\n    getPreviousSibling: getPreviousSibling,\n    getSelection: getSelection,\n    insertBefore: insertBefore,\n    nodeContains: nodeContains,\n    getElementById: getElementById,\n    querySelector: querySelector,\n    querySelectorAll: querySelectorAll\n});\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nclass Tabster {\n  constructor(tabster) {\n    this.keyboardNavigation = tabster.keyboardNavigation;\n    this.focusedElement = tabster.focusedElement;\n    this.focusable = tabster.focusable;\n    this.root = tabster.root;\n    this.uncontrolled = tabster.uncontrolled;\n    this.core = tabster;\n  }\n\n}\n/**\r\n * Extends Window to include an internal Tabster instance.\r\n */\n\n\nclass TabsterCore {\n  constructor(win, props) {\n    var _a, _b;\n\n    this._forgetMemorizedElements = [];\n    this._wrappers = new Set();\n    this._initQueue = [];\n    this._version = \"6.0.0\";\n    this._noop = false;\n\n    this.getWindow = () => {\n      if (!this._win) {\n        throw new Error(\"Using disposed Tabster.\");\n      }\n\n      return this._win;\n    };\n\n    this._storage = createWeakMap(win);\n    this._win = win;\n    const getWindow = this.getWindow;\n\n    if (props === null || props === void 0 ? void 0 : props.DOMAPI) {\n      setDOMAPI({ ...props.DOMAPI\n      });\n    }\n\n    this.keyboardNavigation = new KeyboardNavigationState(getWindow);\n    this.focusedElement = new FocusedElementState(this, getWindow);\n    this.focusable = new FocusableAPI(this);\n    this.root = new RootAPI(this, props === null || props === void 0 ? void 0 : props.autoRoot);\n    this.uncontrolled = new UncontrolledAPI( // TODO: Remove checkUncontrolledTrappingFocus in the next major version.\n    (props === null || props === void 0 ? void 0 : props.checkUncontrolledCompletely) || (props === null || props === void 0 ? void 0 : props.checkUncontrolledTrappingFocus));\n    this.controlTab = (_a = props === null || props === void 0 ? void 0 : props.controlTab) !== null && _a !== void 0 ? _a : true;\n    this.rootDummyInputs = !!(props === null || props === void 0 ? void 0 : props.rootDummyInputs);\n    this._dummyObserver = new DummyInputObserver(getWindow);\n    this.getParent = (_b = props === null || props === void 0 ? void 0 : props.getParent) !== null && _b !== void 0 ? _b : dom.getParentNode;\n    this.internal = {\n      stopObserver: () => {\n        if (this._unobserve) {\n          this._unobserve();\n\n          delete this._unobserve;\n        }\n      },\n      resumeObserver: syncState => {\n        if (!this._unobserve) {\n          const doc = getWindow().document;\n          this._unobserve = observeMutations(doc, this, updateTabsterByAttribute, syncState);\n        }\n      }\n    };\n    startFakeWeakRefsCleanup(getWindow); // Gives a tick to the host app to initialize other tabster\n    // APIs before tabster starts observing attributes.\n\n    this.queueInit(() => {\n      this.internal.resumeObserver(true);\n    });\n  }\n  /**\r\n   * Merges external props with the current props. Not all\r\n   * props can/should be mergeable, so let's add more as we move on.\r\n   * @param props Tabster props\r\n   */\n\n\n  _mergeProps(props) {\n    var _a;\n\n    if (!props) {\n      return;\n    }\n\n    this.getParent = (_a = props.getParent) !== null && _a !== void 0 ? _a : this.getParent;\n  }\n\n  createTabster(noRefCount, props) {\n    const wrapper = new Tabster(this);\n\n    if (!noRefCount) {\n      this._wrappers.add(wrapper);\n    }\n\n    this._mergeProps(props);\n\n    return wrapper;\n  }\n\n  disposeTabster(wrapper, allInstances) {\n    if (allInstances) {\n      this._wrappers.clear();\n    } else {\n      this._wrappers.delete(wrapper);\n    }\n\n    if (this._wrappers.size === 0) {\n      this.dispose();\n    }\n  }\n\n  dispose() {\n    var _a, _b, _c, _d, _e, _f, _g, _h;\n\n    this.internal.stopObserver();\n    const win = this._win;\n    win === null || win === void 0 ? void 0 : win.clearTimeout(this._initTimer);\n    delete this._initTimer;\n    this._initQueue = [];\n    this._forgetMemorizedElements = [];\n\n    if (win && this._forgetMemorizedTimer) {\n      win.clearTimeout(this._forgetMemorizedTimer);\n      delete this._forgetMemorizedTimer;\n    }\n\n    (_a = this.outline) === null || _a === void 0 ? void 0 : _a.dispose();\n    (_b = this.crossOrigin) === null || _b === void 0 ? void 0 : _b.dispose();\n    (_c = this.deloser) === null || _c === void 0 ? void 0 : _c.dispose();\n    (_d = this.groupper) === null || _d === void 0 ? void 0 : _d.dispose();\n    (_e = this.mover) === null || _e === void 0 ? void 0 : _e.dispose();\n    (_f = this.modalizer) === null || _f === void 0 ? void 0 : _f.dispose();\n    (_g = this.observedElement) === null || _g === void 0 ? void 0 : _g.dispose();\n    (_h = this.restorer) === null || _h === void 0 ? void 0 : _h.dispose();\n    this.keyboardNavigation.dispose();\n    this.focusable.dispose();\n    this.focusedElement.dispose();\n    this.root.dispose();\n\n    this._dummyObserver.dispose();\n\n    stopFakeWeakRefsCleanupAndClearStorage(this.getWindow);\n    clearElementCache(this.getWindow);\n    this._storage = new WeakMap();\n\n    this._wrappers.clear();\n\n    if (win) {\n      disposeInstanceContext(win);\n      delete win.__tabsterInstance;\n      delete this._win;\n    }\n  }\n\n  storageEntry(element, addremove) {\n    const storage = this._storage;\n    let entry = storage.get(element);\n\n    if (entry) {\n      if (addremove === false && Object.keys(entry).length === 0) {\n        storage.delete(element);\n      }\n    } else if (addremove === true) {\n      entry = {};\n      storage.set(element, entry);\n    }\n\n    return entry;\n  }\n\n  forceCleanup() {\n    if (!this._win) {\n      return;\n    }\n\n    this._forgetMemorizedElements.push(this._win.document.body);\n\n    if (this._forgetMemorizedTimer) {\n      return;\n    }\n\n    this._forgetMemorizedTimer = this._win.setTimeout(() => {\n      delete this._forgetMemorizedTimer;\n\n      for (let el = this._forgetMemorizedElements.shift(); el; el = this._forgetMemorizedElements.shift()) {\n        clearElementCache(this.getWindow, el);\n        FocusedElementState.forgetMemorized(this.focusedElement, el);\n      }\n    }, 0);\n    cleanupFakeWeakRefs(this.getWindow, true);\n  }\n\n  queueInit(callback) {\n    var _a;\n\n    if (!this._win) {\n      return;\n    }\n\n    this._initQueue.push(callback);\n\n    if (!this._initTimer) {\n      this._initTimer = (_a = this._win) === null || _a === void 0 ? void 0 : _a.setTimeout(() => {\n        delete this._initTimer;\n        this.drainInitQueue();\n      }, 0);\n    }\n  }\n\n  drainInitQueue() {\n    if (!this._win) {\n      return;\n    }\n\n    const queue = this._initQueue; // Resetting the queue before calling the callbacks to avoid recursion.\n\n    this._initQueue = [];\n    queue.forEach(callback => callback());\n  }\n\n}\n\nfunction forceCleanup(tabster) {\n  // The only legit case for calling this method is when you've completely removed\n  // the application DOM and not going to add the new one for a while.\n  const tabsterCore = tabster.core;\n  tabsterCore.forceCleanup();\n}\n/**\r\n * Creates an instance of Tabster, returns the current window instance if it already exists.\r\n */\n\nfunction createTabster(win, props) {\n  let tabster = getCurrentTabster(win);\n\n  if (tabster) {\n    return tabster.createTabster(false, props);\n  }\n\n  tabster = new TabsterCore(win, props);\n  win.__tabsterInstance = tabster;\n  return tabster.createTabster();\n}\n/**\r\n * Returns an instance of Tabster if it was created before or null.\r\n */\n\nfunction getTabster(win) {\n  const tabster = getCurrentTabster(win);\n  return tabster ? tabster.createTabster(true) : null;\n}\nfunction getShadowDOMAPI() {\n  return shadowDOMAPI;\n}\n/**\r\n * Creates a new groupper instance or returns an existing one\r\n * @param tabster Tabster instance\r\n */\n\nfunction getGroupper(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.groupper) {\n    tabsterCore.groupper = new GroupperAPI(tabsterCore, tabsterCore.getWindow);\n  }\n\n  return tabsterCore.groupper;\n}\n/**\r\n * Creates a new mover instance or returns an existing one\r\n * @param tabster Tabster instance\r\n */\n\nfunction getMover(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.mover) {\n    tabsterCore.mover = new MoverAPI(tabsterCore, tabsterCore.getWindow);\n  }\n\n  return tabsterCore.mover;\n}\nfunction getOutline(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.outline) {\n    tabsterCore.outline = new OutlineAPI(tabsterCore);\n  }\n\n  return tabsterCore.outline;\n}\n/**\r\n * Creates a new new deloser instance or returns an existing one\r\n * @param tabster Tabster instance\r\n * @param props Deloser props\r\n */\n\nfunction getDeloser(tabster, props) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.deloser) {\n    tabsterCore.deloser = new DeloserAPI(tabsterCore, props);\n  }\n\n  return tabsterCore.deloser;\n}\n/**\r\n * Creates a new modalizer instance or returns an existing one\r\n * @param tabster Tabster instance\r\n * @param alwaysAccessibleSelector When Modalizer is active, we put\r\n * aria-hidden to everything else to hide it from screen readers. This CSS\r\n * selector allows to exclude some elements from this behaviour. For example,\r\n * this could be used to exclude aria-live region with the application-wide\r\n * status announcements.\r\n * @param accessibleCheck An optional callback that will be called when\r\n * active Modalizer wants to hide an element that doesn't belong to it from\r\n * the screen readers by setting aria-hidden. Similar to alwaysAccessibleSelector\r\n * but allows to address the elements programmatically rather than with a selector.\r\n * If the callback returns true, the element will not receive aria-hidden.\r\n */\n\nfunction getModalizer(tabster, // @deprecated use accessibleCheck.\nalwaysAccessibleSelector, accessibleCheck) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.modalizer) {\n    tabsterCore.modalizer = new ModalizerAPI(tabsterCore, alwaysAccessibleSelector, accessibleCheck);\n  }\n\n  return tabsterCore.modalizer;\n}\nfunction getObservedElement(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.observedElement) {\n    tabsterCore.observedElement = new ObservedElementAPI(tabsterCore);\n  }\n\n  return tabsterCore.observedElement;\n}\nfunction getCrossOrigin(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.crossOrigin) {\n    getDeloser(tabster);\n    getModalizer(tabster);\n    getMover(tabster);\n    getGroupper(tabster);\n    getOutline(tabster);\n    getObservedElement(tabster);\n    tabsterCore.crossOrigin = new CrossOriginAPI(tabsterCore);\n  }\n\n  return tabsterCore.crossOrigin;\n}\nfunction getInternal(tabster) {\n  const tabsterCore = tabster.core;\n  return tabsterCore.internal;\n}\nfunction getRestorer(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.restorer) {\n    tabsterCore.restorer = new RestorerAPI(tabsterCore);\n  }\n\n  return tabsterCore.restorer;\n}\nfunction disposeTabster(tabster, allInstances) {\n  tabster.core.disposeTabster(tabster, allInstances);\n}\n/**\r\n * Returns an instance of Tabster if it already exists on the window .\r\n * @param win window instance that could contain an Tabster instance.\r\n */\n\nfunction getCurrentTabster(win) {\n  return win.__tabsterInstance;\n}\n/**\r\n * Allows to make Tabster non operational. Intended for performance debugging (and other\r\n * kinds of debugging), you can switch Tabster off without changing the application code\r\n * that consumes it.\r\n * @param tabster a reference created by createTabster().\r\n * @param noop true if you want to make Tabster noop, false if you want to turn it back.\r\n */\n\nfunction makeNoOp(tabster, noop) {\n  const core = tabster.core;\n\n  if (core._noop !== noop) {\n    core._noop = noop;\n\n    const processNode = element => {\n      if (!element.getAttribute) {\n        return NodeFilter.FILTER_SKIP;\n      }\n\n      if (getTabsterOnElement(core, element) || element.hasAttribute(TabsterAttributeName)) {\n        updateTabsterByAttribute(core, element);\n      }\n\n      return NodeFilter.FILTER_SKIP;\n    };\n\n    const doc = core.getWindow().document;\n    const body = doc.body;\n    processNode(body);\n    const walker = createElementTreeWalker(doc, body, processNode);\n\n    if (walker) {\n      while (walker.nextNode()) {\n        /* Iterating for the sake of calling processNode() callback. */\n      }\n    }\n  }\n}\nfunction isNoOp(tabster) {\n  return tabster._noop;\n}\n\nexport { Types, createTabster, dispatchGroupperMoveFocusEvent, dispatchMoverMoveFocusEvent, disposeTabster, forceCleanup, getCrossOrigin, getDeloser, getGroupper, getInternal, getModalizer, getMover, getObservedElement, getOutline, getRestorer, getShadowDOMAPI, getTabster, getTabsterAttribute, isNoOp, makeNoOp, mergeTabsterProps, setTabsterAttribute };\n//# sourceMappingURL=tabster.esm.js.map\n"],"names":["TabsterAttributeName","TabsterDummyInputAttributeName","DeloserEventName","ModalizerActiveEventName","ModalizerInactiveEventName","MoverEventName","FocusInEventName","FocusOutEventName","MoveFocusEventName","MoverMoveFocusEventName","GroupperMoveFocusEventName","FocusableSelector","join","GroupperMoveFocusActions","Enter","Escape","ObservedElementAccesibilities","Any","Accessible","Focusable","RestoreFocusOrders","History","DeloserDefault","RootDefault","DeloserFirst","RootFirst","Visibilities","Invisible","PartiallyVisible","Visible","RestorerTypes","Source","Target","MoverDirections","Both","Vertical","Horizontal","Grid","GridLinear","MoverKeys","ArrowUp","ArrowDown","ArrowLeft","ArrowRight","PageUp","PageDown","Home","End","GroupperTabbabilities","Unlimited","Limited","LimitedTrapFocus","SysDummyInputsPositions","Auto","Inside","Outside","Types","Object","freeze","__proto__","ModalizerFocusInEventName","ModalizerFocusOutEventName","ModalizerBeforeFocusOutEventName","getTabsterOnElement","tabster","element","_a","storageEntry","updateTabsterByAttribute","dispose","_b","newAttrValue","_noop","undefined","getAttribute","newAttr","entry","attr","string","newValue","JSON","parse","Error","object","e","tabsterOnElement","oldTabsterProps","newTabsterProps","key","keys","root","onRoot","part","observedElement","onObservedElementUpdate","sys","deloser","setProps","createDeloser","createRoot","modalizer","createModalizer","restorer","createRestorer","focusable","groupper","createGroupper","mover","createMover","observed","uncontrolled","outline","console","error","length","dom","createMutationObserver","callback","MutationObserver","createTreeWalker","doc","whatToShow","filter","getParentNode","node","parentNode","getParentElement","parentElement","nodeContains","parent","child","contains","getActiveElement","activeElement","querySelector","selector","querySelectorAll","Array","prototype","slice","call","getElementById","id","getFirstChild","firstChild","getLastChild","lastChild","getNextSibling","nextSibling","getPreviousSibling","previousSibling","getFirstElementChild","firstElementChild","getLastElementChild","lastElementChild","getNextElementSibling","nextElementSibling","getPreviousElementSibling","previousElementSibling","appendChild","insertBefore","referenceChild","getSelection","ref","ownerDocument","_isBrokenIE11","_DOMRect","DOMRect","constructor","x","y","width","height","this","left","top","right","bottom","_uidCounter","document","NodeFilter","SHOW_ELEMENT","getInstanceContext","getWindow","win","ctx","__tabsterInstanceContext","elementByUId","basics","Promise","WeakRef","containerBoundingRectCache","lastContainerBoundingRectCacheId","fakeWeakRefs","fakeWeakRefsStarted","FakeWeakRef","target","_target","deref","cleanup","fwr","forceRemove","documentContains","WeakHTMLElement","data","context","push","_ref","_data","get","getData","cleanupFakeWeakRefs","startFakeWeakRefsCleanup","getWeakRef","fakeWeakRefsTimer","setTimeout","createElementTreeWalker","acceptNode","nodeType","Node","ELEMENT_NODE","getBoundingRect","cacheId","__tabsterCacheId","cached","rect","scrollingElement","documentElement","clientWidth","clientHeight","r","getBoundingClientRect","Math","max","min","containerBoundingRectCacheTimer","window","cId","isElementVerticallyVisibleInContainer","tolerance","container","getScrollableContainer","containerRect","elementRect","intersectionTolerance","totalIntersection","el","scrollWidth","scrollHeight","shouldIgnoreFocus","__shouldIgnoreFocus","getUId","wnd","rnd","Uint32Array","crypto","getRandomValues","msCrypto","i","random","srnd","toString","Date","now","getElementUId","uid","__tabsterElementUID","clearElementCache","wel","body","matchesSelector","matches","msMatchesSelector","webkitMatchesSelector","getPromise","_lastTabsterPartId","TabsterPart","props","_tabster","_element","_props","getElement","getProps","DummyInput","isOutside","fixedTarget","_focusIn","_fixedTarget","input","onFocusIn","relatedTarget","_isBackward","_focusOut","useDefaultAction","onFocusOut","createElement","tabIndex","setAttribute","style","position","opacity","zIndex","setProperty","makeFocusIgnored","isFirst","_isPhantom","isPhantom","addEventListener","__tabsterDummyContainer","_disposeTimer","_clearDisposeTimeout","clearTimeout","removeEventListener","removeChild","setTopLeft","isIn","current","previous","compareDocumentPosition","DOCUMENT_POSITION_FOLLOWING","DummyInputManagerPriorities","DummyInputManager","priority","outsideByDefault","callForDefaultAction","_instance","DummyInputManagerCore","_setHandlers","_onFocusIn","_onFocusOut","moveOut","backwards","moveOutWithDefaultAction","relatedEvent","getHandler","setTabbable","tabbable","moveWithPhantomDummy","moveOutOfElement","isBackward","tagName","potentialDummy","dummyFor","isFocusable","dispatchMoveFocusEvent","by","owner","next","addPhantomDummyWithTarget","sourceElement","targetElement","dummyParent","DummyInputObserver","_updateQueue","Set","_lastUpdateQueueTime","_changedParents","WeakSet","_dummyElements","_dummyCallbacks","WeakMap","_domChanged","has","add","_updateDummyInputsTimer","_win","dummyElement","dummy","set","domChanged","remove","delete","_updateTimer","clear","updatePositions","compute","_scheduledUpdatePositions","scrollTopLeftCache","Map","setTopLeftCallbacks","manager","_wrappers","_isOutside","_transformElements","dummyInput","_onFocus","first","_firstDummy","last","_lastDummy","_ensurePosition","firstInput","lastInput","toFocus","w","wrapper","_getCurrent","_addDummyInputs","_addTimer","_getWindow","_addTransformOffsets","_dummyObserver","_computeTransformOffsets","from","transformElements","newTransformElements","scrollTop","scrollLeft","scrollTopLeft","transform","getComputedStyle","_callForDefaultAction","instance","__tabsterDummy","forcedDummyPosition","dummyInputsPosition","force","_c","_d","sort","a","b","firstDummyInput","lastDummyInput","elementParent","getLastChild$2","triggerEvent","name","detail","event","CustomEvent","bubbles","cancelable","composed","details","dispatchEvent","defaultPrevented","getTabsterAttribute","plain","stringify","setTabsterAttribute","newProps","update","value","mergeTabsterProps","removeAttribute","RootDummyManager","setFocused","super","_onDummyInputFocus","_setFocused","keyboardNavigation","setNavigatingWithKeyboard","focusedElement","getFirstOrLastTabbable","ignoreAccessibility","blur","Root","onDispose","_isFocused","hasFocused","_setFocusedTimer","_dummyManager","eventTarget","getParent","rootElement","curElement","composedPath","_onDispose","_sys","controlTab","rootDummyInputs","addDummyInputs","_add","_remove","dummyManager","RootAPI","autoRoot","_autoRootWaiting","_roots","_forceDummy","rootById","_autoRootCreate","_autoRootUnwait","_autoRoot","_onRootDispose","global","EventTarget","TypeError","createEventTarget","queueInit","forEach","rootId","newRoot","roots","getRootByUId","__tabsterInstance","getTabsterContext","options","checkRtl","referenceElement","drainInitQueue","groupperBeforeMover","modalizerInGroupper","dirRightToLeft","excludedFromMover","ignoreKeydown","dir","toLowerCase","excludeFromMover","curModalizer","curGroupper","curMover","isActive","tabbability","userId","activeId","assign","rootAPI","rtl","getRoot","removed","Subscribable","_callbacks","_val","subscribe","callbacks","indexOf","subscribeFirst","index","splice","unshift","unsubscribe","setVal","val","_callCallbacks","getVal","trigger","FocusableAPI","includeProgrammaticallyFocusable","noVisibleCheck","noAccessibleCheck","isVisible","isAccessible","offsetParent","defaultView","visibility","_isHidden","ignoreAriaDisabled","_isDisabled","hasAttribute","attrVal","isAugmented","findFirst","out","findElement","findLast","findNext","findPrev","findDefault","acceptCondition","isDefault","findAll","_findElements","found","currentElement","useActiveModalizer","modalizerId","onElement","elements","hasCustomCondition","acceptElementState","modalizerUserId","cachedGrouppers","walker","_acceptElement","prepareForNextElement","shouldContinueIfNotFound","foundElement","foundBackward","fromCtx","outOfDOMOrder","currentNode","FILTER_ACCEPT","skippedFocusable","previousNode","nextNode","state","FILTER_SKIP","FILTER_REJECT","rejectElementsFrom","currentCtx","result","fromMover","acceptElement","groupperElement","fromMoverElement","moverElement","Keys","FocusedElementState","_init","_onKeyDown","_setFocusedElement","_onChanged","isFocusedProgrammatically","originalEvent","_validateFocusedElement","keyCode","ctrlKey","contentEditable","shiftKey","findNextTabbable","nextElement","uncontrolledCompletelyContainer","uncontrolledOnElement","isUncontrolledCompletely","completely","getUncontrolledCompletelyContainer","nextUncontrolled","preventDefault","stopImmediatePropagation","_lastVal","d","lastCtx","_lastResetElement","_nextVal","forgetMemorized","getFocusedElement","getLastFocusedElement","focus","noFocusedProgrammaticallyFlag","focusDefault","_focusFirstOrLast","focusFirst","focusLast","resetFocus","prevTabIndex","prevAriaHidden","_setOrRemoveAttribute","lastResetElement","nextVal","actualContainer","isTabbingTimer","_isTabbingTimer","isTabbing","callFindNext","what","parentCtx","currentScopeElement","newCurrent","findProps","findPropsOut","GroupperDummyManager","prev","cur","adjacent","getAdjacentElement","Groupper","_shouldTabInside","makeTabbable","_first","currentIsDummy","groupperFirstFocusable","getFirst","isTabbable","noIfFirstIsFocused","isParentActive","g","ret","focused","orContainer","setFirst","parentCtxGroupper","parentGroupper","parentGroupperElement","getIsActive","GroupperAPI","_current","_grouppers","_onMouseDown","_onMoveFocus","_onGroupperDispose","_updateCurrent","altKey","metaKey","handleKeyPress","action","_enterGroupper","_escapeGroupper","_handleKeyPressTimer","groupperId","newGroupper","forgetCurrentGrouppers","includeTarget","checkTarget","newIds","isTarget","delegated","fromModalizer","setActive","moveFocus","KeyboardNavigationState","_onChange","isNavigatingWithKeyboard","_keyborg","_inputSelector","MoverDummyManager","getMemorized","_onFocusDummyInput","memorized","_getMemorized","Mover","_visible","_onIntersection","entries","newVisibility","fullyVisible","_fullyVisible","intersectionRatio","getState","visibilityTolerance","trackState","visibilityAware","_intersectionObserver","IntersectionObserver","threshold","_observeState","memorizeCurrent","disconnect","_allElements","_unobserve","_setCurrentTimer","setCurrent","changed","_prevCurrent","weak","getCurrent","hasDefault","allElements","tabsterFocusable","updateQueue","observer","mutations","mutation","removedNodes","added","addedNodes","type","attributeName","requestUpdate","setElement","unobserve","observe","updateElement","addNewElements","getMoverGroupper","removeWalk","toe","childList","subtree","attributes","attributeFilter","isCurrent","MoverAPI","_onMoverDispose","_movers","currentFocusableElement","deepestFocusableElement","async","_ignoredInputTimer","_ignoredInputResolve","moverKey","_isIgnoredInput","_moveFocus","moverId","newMover","fromElement","moverProps","direction","isBoth","isVertical","isHorizontal","isGridLinear","isGrid","isCyclic","cyclic","scrollIntoViewArg","focusedElementRect","focusedElementX1","focusedElementX2","ceil","floor","nextElementX1","nextElementX2","firstColumnX1","lastColumnX1","ax1","ay1","ax2","ay2","lastDistance","lastIntersection","bx1","by1","bx2","by2","xIntersectionWidth","minWidth","intersection","distance","xDistance","yDistance","sqrt","getDistance","alignToTop","scrollIntoView","asyncRet","selectionStart","selectionEnd","textLength","selection","initialLength","modify","selStart","resolve","anchorNode","prevAnchorNode","focusNode","prevFocusNode","anchorOffset","prevAnchorOffset","focusOffset","prevFocusOffset","textContent","anchorFound","addOffsets","nodeText","len","stop","UncontrolledAPI","_isUncontrolledCompletely","otherNode","assignedElements","assignedSlot","DOCUMENT_FRAGMENT_NODE","host","ShadowMutationObserver","_overrideAttachShadow","origAttachShadow","Element","attachShadow","__origAttachShadow","shadowRoot","shadowObserver","_shadowObservers","_addSubObserver","_isObserving","_callbackWrapper","_walkShadows","_callback","_observer","_subObservers","_options","_root","subObserver","values","DOCUMENT_NODE","takeRecords","records","Tabster","core","TabsterCore","_forgetMemorizedElements","_initQueue","_version","_storage","createWeakMap","DOMAPI","domapi","setDOMAPI","checkUncontrolledCompletely","checkUncontrolledTrappingFocus","internal","stopObserver","resumeObserver","syncState","updateTabsterElements","processNode","_e","hiddenUpdate","observeMutations","_mergeProps","createTabster","noRefCount","disposeTabster","allInstances","size","_f","_g","_h","_initTimer","_forgetMemorizedTimer","crossOrigin","stopFakeWeakRefsCleanupAndClearStorage","disposeInstanceContext","addremove","storage","forceCleanup","shift","queue","getCurrentTabster","getGroupper","tabsterCore","getMover"],"sourceRoot":""}