{"version":3,"file":"focus-lock-CAkr-jOZ.js","sources":["../../node_modules/focus-lock/dist/es2015/constants.js","../../node_modules/focus-lock/dist/es2015/utils/array.js","../../node_modules/focus-lock/dist/es2015/utils/is.js","../../node_modules/focus-lock/dist/es2015/utils/tabOrder.js","../../node_modules/focus-lock/dist/es2015/utils/tabbables.js","../../node_modules/focus-lock/dist/es2015/utils/tabUtils.js","../../node_modules/focus-lock/dist/es2015/utils/DOMutils.js","../../node_modules/focus-lock/dist/es2015/utils/all-affected.js","../../node_modules/focus-lock/dist/es2015/utils/safe.js","../../node_modules/focus-lock/dist/es2015/utils/getActiveElement.js","../../node_modules/focus-lock/dist/es2015/focusInside.js","../../node_modules/focus-lock/dist/es2015/focusIsHidden.js","../../node_modules/focus-lock/dist/es2015/utils/correctFocus.js","../../node_modules/focus-lock/dist/es2015/utils/firstFocus.js","../../node_modules/focus-lock/dist/es2015/solver.js","../../node_modules/focus-lock/dist/es2015/utils/auto-focus.js","../../node_modules/focus-lock/dist/es2015/utils/parenting.js","../../node_modules/focus-lock/dist/es2015/focusSolver.js","../../node_modules/focus-lock/dist/es2015/focusables.js","../../node_modules/focus-lock/dist/es2015/commands.js","../../node_modules/focus-lock/dist/es2015/moveFocusInside.js","../../node_modules/focus-lock/dist/es2015/return-focus.js","../../node_modules/focus-lock/dist/es2015/sibling.js"],"sourcesContent":["/**\n * defines a focus group\n */\nexport var FOCUS_GROUP = 'data-focus-lock';\n/**\n * disables element discovery inside a group marked by key\n */\nexport var FOCUS_DISABLED = 'data-focus-lock-disabled';\n/**\n * allows uncontrolled focus within the marked area, effectively disabling focus lock for it's content\n */\nexport var FOCUS_ALLOW = 'data-no-focus-lock';\n/**\n * instructs autofocus engine to pick default autofocus inside a given node\n * can be set on the element or container\n */\nexport var FOCUS_AUTO = 'data-autofocus-inside';\n/**\n * instructs autofocus to ignore elements within a given node\n * can be set on the element or container\n */\nexport var FOCUS_NO_AUTOFOCUS = 'data-no-autofocus';\n","/*\nIE11 support\n */\nexport var toArray = function (a) {\n    var ret = Array(a.length);\n    for (var i = 0; i < a.length; ++i) {\n        ret[i] = a[i];\n    }\n    return ret;\n};\nexport var asArray = function (a) { return (Array.isArray(a) ? a : [a]); };\nexport var getFirst = function (a) { return (Array.isArray(a) ? a[0] : a); };\n","import { FOCUS_NO_AUTOFOCUS } from '../constants';\nvar isElementHidden = function (node) {\n    // we can measure only \"elements\"\n    // consider others as \"visible\"\n    if (node.nodeType !== Node.ELEMENT_NODE) {\n        return false;\n    }\n    var computedStyle = window.getComputedStyle(node, null);\n    if (!computedStyle || !computedStyle.getPropertyValue) {\n        return false;\n    }\n    return (computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden');\n};\nvar getParentNode = function (node) {\n    // DOCUMENT_FRAGMENT_NODE can also point on ShadowRoot. In this case .host will point on the next node\n    return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            node.parentNode.host\n        : node.parentNode;\n};\nvar isTopNode = function (node) {\n    // @ts-ignore\n    return node === document || (node && node.nodeType === Node.DOCUMENT_NODE);\n};\nvar isInert = function (node) { return node.hasAttribute('inert'); };\n/**\n * @see https://github.com/testing-library/jest-dom/blob/main/src/to-be-visible.js\n */\nvar isVisibleUncached = function (node, checkParent) {\n    return !node || isTopNode(node) || (!isElementHidden(node) && !isInert(node) && checkParent(getParentNode(node)));\n};\nexport var isVisibleCached = function (visibilityCache, node) {\n    var cached = visibilityCache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isVisibleUncached(node, isVisibleCached.bind(undefined, visibilityCache));\n    visibilityCache.set(node, result);\n    return result;\n};\nvar isAutoFocusAllowedUncached = function (node, checkParent) {\n    return node && !isTopNode(node) ? (isAutoFocusAllowed(node) ? checkParent(getParentNode(node)) : false) : true;\n};\nexport var isAutoFocusAllowedCached = function (cache, node) {\n    var cached = cache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(undefined, cache));\n    cache.set(node, result);\n    return result;\n};\nexport var getDataset = function (node) {\n    // @ts-ignore\n    return node.dataset;\n};\nexport var isHTMLButtonElement = function (node) { return node.tagName === 'BUTTON'; };\nexport var isHTMLInputElement = function (node) { return node.tagName === 'INPUT'; };\nexport var isRadioElement = function (node) {\n    return isHTMLInputElement(node) && node.type === 'radio';\n};\nexport var notHiddenInput = function (node) {\n    return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && (node.type === 'hidden' || node.disabled));\n};\nexport var isAutoFocusAllowed = function (node) {\n    var attribute = node.getAttribute(FOCUS_NO_AUTOFOCUS);\n    return ![true, 'true', ''].includes(attribute);\n};\nexport var isGuard = function (node) { var _a; return Boolean(node && ((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.focusGuard)); };\nexport var isNotAGuard = function (node) { return !isGuard(node); };\nexport var isDefined = function (x) { return Boolean(x); };\n","import { toArray } from './array';\nexport var tabSort = function (a, b) {\n    var aTab = Math.max(0, a.tabIndex);\n    var bTab = Math.max(0, b.tabIndex);\n    var tabDiff = aTab - bTab;\n    var indexDiff = a.index - b.index;\n    if (tabDiff) {\n        if (!aTab) {\n            return 1;\n        }\n        if (!bTab) {\n            return -1;\n        }\n    }\n    return tabDiff || indexDiff;\n};\nvar getTabIndex = function (node) {\n    if (node.tabIndex < 0) {\n        // all \"focusable\" elements are already preselected\n        // but some might have implicit negative tabIndex\n        // return 0 for <audio without tabIndex attribute - it is \"tabbable\"\n        if (!node.hasAttribute('tabindex')) {\n            return 0;\n        }\n    }\n    return node.tabIndex;\n};\nexport var orderByTabIndex = function (nodes, filterNegative, keepGuards) {\n    return toArray(nodes)\n        .map(function (node, index) {\n        var tabIndex = getTabIndex(node);\n        return {\n            node: node,\n            index: index,\n            tabIndex: keepGuards && tabIndex === -1 ? ((node.dataset || {}).focusGuard ? 0 : -1) : tabIndex,\n        };\n    })\n        .filter(function (data) { return !filterNegative || data.tabIndex >= 0; })\n        .sort(tabSort);\n};\n","/**\n * list of the object to be considered as focusable\n */\nexport var tabbables = [\n    'button:enabled',\n    'select:enabled',\n    'textarea:enabled',\n    'input:enabled',\n    // elements with explicit roles will also use explicit tabindex\n    // '[role=\"button\"]',\n    'a[href]',\n    'area[href]',\n    'summary',\n    'iframe',\n    'object',\n    'embed',\n    'audio[controls]',\n    'video[controls]',\n    '[tabindex]',\n    '[contenteditable]',\n    '[autofocus]',\n];\n","import { FOCUS_AUTO } from '../constants';\nimport { toArray } from './array';\nimport { tabbables } from './tabbables';\nvar queryTabbables = tabbables.join(',');\nvar queryGuardTabbables = \"\".concat(queryTabbables, \", [data-focus-guard]\");\nvar getFocusablesWithShadowDom = function (parent, withGuards) {\n    return toArray((parent.shadowRoot || parent).children).reduce(function (acc, child) {\n        return acc.concat(child.matches(withGuards ? queryGuardTabbables : queryTabbables) ? [child] : [], getFocusablesWithShadowDom(child));\n    }, []);\n};\nvar getFocusablesWithIFrame = function (parent, withGuards) {\n    var _a;\n    // contentDocument of iframe will be null if current origin cannot access it\n    if (parent instanceof HTMLIFrameElement && ((_a = parent.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) {\n        return getFocusables([parent.contentDocument.body], withGuards);\n    }\n    return [parent];\n};\nexport var getFocusables = function (parents, withGuards) {\n    return parents.reduce(function (acc, parent) {\n        var _a;\n        var focusableWithShadowDom = getFocusablesWithShadowDom(parent, withGuards);\n        var focusableWithIframes = (_a = []).concat.apply(_a, focusableWithShadowDom.map(function (node) { return getFocusablesWithIFrame(node, withGuards); }));\n        return acc.concat(\n        // add all tabbables inside and within shadow DOMs in DOM order\n        focusableWithIframes, \n        // add if node is tabbable itself\n        parent.parentNode\n            ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function (node) { return node === parent; })\n            : []);\n    }, []);\n};\n/**\n * return a list of focusable nodes within an area marked as \"auto-focusable\"\n * @param parent\n */\nexport var getParentAutofocusables = function (parent) {\n    var parentFocus = parent.querySelectorAll(\"[\".concat(FOCUS_AUTO, \"]\"));\n    return toArray(parentFocus)\n        .map(function (node) { return getFocusables([node]); })\n        .reduce(function (acc, nodes) { return acc.concat(nodes); }, []);\n};\n","import { toArray } from './array';\nimport { isAutoFocusAllowedCached, isVisibleCached, notHiddenInput } from './is';\nimport { orderByTabIndex } from './tabOrder';\nimport { getFocusables, getParentAutofocusables } from './tabUtils';\n/**\n * given list of focusable elements keeps the ones user can interact with\n * @param nodes\n * @param visibilityCache\n */\nexport var filterFocusable = function (nodes, visibilityCache) {\n    return toArray(nodes)\n        .filter(function (node) { return isVisibleCached(visibilityCache, node); })\n        .filter(function (node) { return notHiddenInput(node); });\n};\nexport var filterAutoFocusable = function (nodes, cache) {\n    if (cache === void 0) { cache = new Map(); }\n    return toArray(nodes).filter(function (node) { return isAutoFocusAllowedCached(cache, node); });\n};\n/**\n * !__WARNING__! Low level API.\n * @returns all tabbable nodes\n *\n * @see {@link getFocusableNodes} to get any focusable element\n *\n * @param topNodes - array of top level HTMLElements to search inside\n * @param visibilityCache - an cache to store intermediate measurements. Expected to be a fresh `new Map` on every call\n */\nexport var getTabbableNodes = function (topNodes, visibilityCache, withGuards) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), true, withGuards);\n};\n/**\n * !__WARNING__! Low level API.\n *\n * @returns anything \"focusable\", not only tabbable. The difference is in `tabIndex=-1`\n * (without guards, as long as they are not expected to be ever focused)\n *\n * @see {@link getTabbableNodes} to get only tabble nodes element\n *\n * @param topNodes - array of top level HTMLElements to search inside\n * @param visibilityCache - an cache to store intermediate measurements. Expected to be a fresh `new Map` on every call\n */\nexport var getFocusableNodes = function (topNodes, visibilityCache) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), false);\n};\n/**\n * return list of nodes which are expected to be auto-focused\n * @param topNode\n * @param visibilityCache\n */\nexport var parentAutofocusables = function (topNode, visibilityCache) {\n    return filterFocusable(getParentAutofocusables(topNode), visibilityCache);\n};\n/*\n * Determines if element is contained in scope, including nested shadow DOMs\n */\nexport var contains = function (scope, element) {\n    if (scope.shadowRoot) {\n        return contains(scope.shadowRoot, element);\n    }\n    else {\n        if (Object.getPrototypeOf(scope).contains !== undefined &&\n            Object.getPrototypeOf(scope).contains.call(scope, element)) {\n            return true;\n        }\n        return toArray(scope.children).some(function (child) {\n            var _a;\n            if (child instanceof HTMLIFrameElement) {\n                var iframeBody = (_a = child.contentDocument) === null || _a === void 0 ? void 0 : _a.body;\n                if (iframeBody) {\n                    return contains(iframeBody, element);\n                }\n                return false;\n            }\n            return contains(child, element);\n        });\n    }\n};\n","import { FOCUS_DISABLED, FOCUS_GROUP } from '../constants';\nimport { asArray, toArray } from './array';\n/**\n * in case of multiple nodes nested inside each other\n * keeps only top ones\n * this is O(nlogn)\n * @param nodes\n * @returns {*}\n */\nvar filterNested = function (nodes) {\n    var contained = new Set();\n    var l = nodes.length;\n    for (var i = 0; i < l; i += 1) {\n        for (var j = i + 1; j < l; j += 1) {\n            var position = nodes[i].compareDocumentPosition(nodes[j]);\n            /* eslint-disable no-bitwise */\n            if ((position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0) {\n                contained.add(j);\n            }\n            if ((position & Node.DOCUMENT_POSITION_CONTAINS) > 0) {\n                contained.add(i);\n            }\n            /* eslint-enable */\n        }\n    }\n    return nodes.filter(function (_, index) { return !contained.has(index); });\n};\n/**\n * finds top most parent for a node\n * @param node\n * @returns {*}\n */\nvar getTopParent = function (node) {\n    return node.parentNode ? getTopParent(node.parentNode) : node;\n};\n/**\n * returns all \"focus containers\" inside a given node\n * @param node - node or nodes to look inside\n * @returns Element[]\n */\nexport var getAllAffectedNodes = function (node) {\n    var nodes = asArray(node);\n    return nodes.filter(Boolean).reduce(function (acc, currentNode) {\n        var group = currentNode.getAttribute(FOCUS_GROUP);\n        acc.push.apply(acc, (group\n            ? filterNested(toArray(getTopParent(currentNode).querySelectorAll(\"[\".concat(FOCUS_GROUP, \"=\\\"\").concat(group, \"\\\"]:not([\").concat(FOCUS_DISABLED, \"=\\\"disabled\\\"])\"))))\n            : [currentNode]));\n        return acc;\n    }, []);\n};\n","export var safeProbe = function (cb) {\n    try {\n        return cb();\n    }\n    catch (e) {\n        return undefined;\n    }\n};\n","/**\n * returns active element from document or from nested shadowdoms\n */\nimport { safeProbe } from './safe';\n/**\n * returns current active element. If the active element is a \"container\" itself(shadowRoot or iframe) returns active element inside it\n * @param [inDocument]\n */\nexport var getActiveElement = function (inDocument) {\n    if (inDocument === void 0) { inDocument = document; }\n    if (!inDocument || !inDocument.activeElement) {\n        return undefined;\n    }\n    var activeElement = inDocument.activeElement;\n    return (activeElement.shadowRoot\n        ? getActiveElement(activeElement.shadowRoot)\n        : activeElement instanceof HTMLIFrameElement && safeProbe(function () { return activeElement.contentWindow.document; })\n            ? getActiveElement(activeElement.contentWindow.document)\n            : activeElement);\n};\n","import { contains } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { getFirst, toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\nvar focusInFrame = function (frame, activeElement) { return frame === activeElement; };\nvar focusInsideIframe = function (topNode, activeElement) {\n    return Boolean(toArray(topNode.querySelectorAll('iframe')).some(function (node) { return focusInFrame(node, activeElement); }));\n};\n/**\n * @returns {Boolean} true, if the current focus is inside given node or nodes.\n * Supports nodes hidden inside shadowDom\n */\nexport var focusInside = function (topNode, activeElement) {\n    // const activeElement = document && getActiveElement();\n    if (activeElement === void 0) { activeElement = getActiveElement(getFirst(topNode).ownerDocument); }\n    if (!activeElement || (activeElement.dataset && activeElement.dataset.focusGuard)) {\n        return false;\n    }\n    return getAllAffectedNodes(topNode).some(function (node) {\n        return contains(node, activeElement) || focusInsideIframe(node, activeElement);\n    });\n};\n","import { FOCUS_ALLOW } from './constants';\nimport { contains } from './utils/DOMutils';\nimport { toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\n/**\n * checks if focus is hidden FROM the focus-lock\n * ie contained inside a node focus-lock shall ignore\n *\n * This is a utility function coupled with {@link FOCUS_ALLOW} constant\n *\n * @returns {boolean} focus is currently is in \"allow\" area\n */\nexport var focusIsHidden = function (inDocument) {\n    if (inDocument === void 0) { inDocument = document; }\n    var activeElement = getActiveElement(inDocument);\n    if (!activeElement) {\n        return false;\n    }\n    // this does not support setting FOCUS_ALLOW within shadow dom\n    return toArray(inDocument.querySelectorAll(\"[\".concat(FOCUS_ALLOW, \"]\"))).some(function (node) { return contains(node, activeElement); });\n};\n","import { isRadioElement } from './is';\nvar findSelectedRadio = function (node, nodes) {\n    return nodes\n        .filter(isRadioElement)\n        .filter(function (el) { return el.name === node.name; })\n        .filter(function (el) { return el.checked; })[0] || node;\n};\nexport var correctNode = function (node, nodes) {\n    if (isRadioElement(node) && node.name) {\n        return findSelectedRadio(node, nodes);\n    }\n    return node;\n};\n/**\n * giving a set of radio inputs keeps only selected (tabbable) ones\n * @param nodes\n */\nexport var correctNodes = function (nodes) {\n    // IE11 has no Set(array) constructor\n    var resultSet = new Set();\n    nodes.forEach(function (node) { return resultSet.add(correctNode(node, nodes)); });\n    // using filter to support IE11\n    return nodes.filter(function (node) { return resultSet.has(node); });\n};\n","import { correctNode } from './correctFocus';\nexport var pickFirstFocus = function (nodes) {\n    if (nodes[0] && nodes.length > 1) {\n        return correctNode(nodes[0], nodes);\n    }\n    return nodes[0];\n};\nexport var pickFocusable = function (nodes, node) {\n    return nodes.indexOf(correctNode(node, nodes));\n};\n","import { correctNodes } from './utils/correctFocus';\nimport { pickFocusable } from './utils/firstFocus';\nimport { isGuard } from './utils/is';\nexport var NEW_FOCUS = 'NEW_FOCUS';\n/**\n * Main solver for the \"find next focus\" question\n * @param innerNodes - used to control \"return focus\"\n * @param innerTabbables - used to control \"autofocus\"\n * @param outerNodes\n * @param activeElement\n * @param lastNode\n * @returns {number|string|undefined|*}\n */\nexport var newFocus = function (innerNodes, innerTabbables, outerNodes, activeElement, lastNode) {\n    var cnt = innerNodes.length;\n    var firstFocus = innerNodes[0];\n    var lastFocus = innerNodes[cnt - 1];\n    var isOnGuard = isGuard(activeElement);\n    // focus is inside\n    if (activeElement && innerNodes.indexOf(activeElement) >= 0) {\n        return undefined;\n    }\n    var activeIndex = activeElement !== undefined ? outerNodes.indexOf(activeElement) : -1;\n    var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;\n    var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;\n    // no active focus (or focus is on the body)\n    if (activeIndex === -1) {\n        // known fallback\n        if (lastNodeInside !== -1) {\n            return lastNodeInside;\n        }\n        return NEW_FOCUS;\n    }\n    // new focus, nothing to calculate\n    if (lastNodeInside === -1) {\n        return NEW_FOCUS;\n    }\n    var indexDiff = activeIndex - lastIndex;\n    var firstNodeIndex = outerNodes.indexOf(firstFocus);\n    var lastNodeIndex = outerNodes.indexOf(lastFocus);\n    var correctedNodes = correctNodes(outerNodes);\n    var correctedIndex = activeElement !== undefined ? correctedNodes.indexOf(activeElement) : -1;\n    var correctedIndexDiff = correctedIndex - (lastNode ? correctedNodes.indexOf(lastNode) : activeIndex);\n    // old focus\n    if (!indexDiff && lastNodeInside >= 0) {\n        return lastNodeInside;\n    }\n    // no tabbable elements, autofocus is not possible\n    if (innerTabbables.length === 0) {\n        // an edge case with no tabbable elements\n        // return the last focusable one\n        // with some probability this will prevent focus from cycling across the lock, but there is no tabbale elements to cycle to\n        return lastNodeInside;\n    }\n    var returnFirstNode = pickFocusable(innerNodes, innerTabbables[0]);\n    var returnLastNode = pickFocusable(innerNodes, innerTabbables[innerTabbables.length - 1]);\n    // first element\n    if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnLastNode;\n    }\n    // last element\n    if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnFirstNode;\n    }\n    // jump out, but not on the guard\n    if (indexDiff && Math.abs(correctedIndexDiff) > 1) {\n        return lastNodeInside;\n    }\n    // focus above lock\n    if (activeIndex <= firstNodeIndex) {\n        return returnLastNode;\n    }\n    // focus below lock\n    if (activeIndex > lastNodeIndex) {\n        return returnFirstNode;\n    }\n    // index is inside tab order, but outside Lock\n    if (indexDiff) {\n        if (Math.abs(indexDiff) > 1) {\n            return lastNodeInside;\n        }\n        return (cnt + lastNodeInside + indexDiff) % cnt;\n    }\n    // do nothing\n    return undefined;\n};\n","import { filterAutoFocusable } from './DOMutils';\nimport { pickFirstFocus } from './firstFocus';\nimport { getDataset } from './is';\nvar findAutoFocused = function (autoFocusables) {\n    return function (node) {\n        var _a;\n        var autofocus = (_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.autofocus;\n        return (\n        // @ts-expect-error\n        node.autofocus ||\n            //\n            (autofocus !== undefined && autofocus !== 'false') ||\n            //\n            autoFocusables.indexOf(node) >= 0);\n    };\n};\nexport var pickAutofocus = function (nodesIndexes, orderedNodes, groups) {\n    var nodes = nodesIndexes.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var autoFocusable = filterAutoFocusable(nodes.filter(findAutoFocused(groups)));\n    if (autoFocusable && autoFocusable.length) {\n        return pickFirstFocus(autoFocusable);\n    }\n    return pickFirstFocus(filterAutoFocusable(orderedNodes));\n};\n","import { parentAutofocusables } from './DOMutils';\nimport { contains } from './DOMutils';\nimport { asArray } from './array';\nvar getParents = function (node, parents) {\n    if (parents === void 0) { parents = []; }\n    parents.push(node);\n    if (node.parentNode) {\n        getParents(node.parentNode.host || node.parentNode, parents);\n    }\n    return parents;\n};\n/**\n * finds a parent for both nodeA and nodeB\n * @param nodeA\n * @param nodeB\n * @returns {boolean|*}\n */\nexport var getCommonParent = function (nodeA, nodeB) {\n    var parentsA = getParents(nodeA);\n    var parentsB = getParents(nodeB);\n    // tslint:disable-next-line:prefer-for-of\n    for (var i = 0; i < parentsA.length; i += 1) {\n        var currentParent = parentsA[i];\n        if (parentsB.indexOf(currentParent) >= 0) {\n            return currentParent;\n        }\n    }\n    return false;\n};\nexport var getTopCommonParent = function (baseActiveElement, leftEntry, rightEntries) {\n    var activeElements = asArray(baseActiveElement);\n    var leftEntries = asArray(leftEntry);\n    var activeElement = activeElements[0];\n    var topCommon = false;\n    leftEntries.filter(Boolean).forEach(function (entry) {\n        topCommon = getCommonParent(topCommon || entry, entry) || topCommon;\n        rightEntries.filter(Boolean).forEach(function (subEntry) {\n            var common = getCommonParent(activeElement, subEntry);\n            if (common) {\n                if (!topCommon || contains(common, topCommon)) {\n                    topCommon = common;\n                }\n                else {\n                    topCommon = getCommonParent(common, topCommon);\n                }\n            }\n        });\n    });\n    // TODO: add assert here?\n    return topCommon;\n};\n/**\n * return list of nodes which are expected to be autofocused inside a given top nodes\n * @param entries\n * @param visibilityCache\n */\nexport var allParentAutofocusables = function (entries, visibilityCache) {\n    return entries.reduce(function (acc, node) { return acc.concat(parentAutofocusables(node, visibilityCache)); }, []);\n};\n","import { NEW_FOCUS, newFocus } from './solver';\nimport { getFocusableNodes } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { asArray, getFirst } from './utils/array';\nimport { pickAutofocus } from './utils/auto-focus';\nimport { getActiveElement } from './utils/getActiveElement';\nimport { isDefined, isNotAGuard } from './utils/is';\nimport { allParentAutofocusables, getTopCommonParent } from './utils/parenting';\nvar reorderNodes = function (srcNodes, dstNodes) {\n    var remap = new Map();\n    // no Set(dstNodes) for IE11 :(\n    dstNodes.forEach(function (entity) { return remap.set(entity.node, entity); });\n    // remap to dstNodes\n    return srcNodes.map(function (node) { return remap.get(node); }).filter(isDefined);\n};\n/**\n * contains the main logic of the `focus-lock` package.\n *\n * ! you probably dont need this function !\n *\n * given top node(s) and the last active element returns the element to be focused next\n * @returns element which should be focused to move focus inside\n * @param topNode\n * @param lastNode\n */\nexport var focusSolver = function (topNode, lastNode) {\n    var activeElement = getActiveElement(asArray(topNode).length > 0 ? document : getFirst(topNode).ownerDocument);\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);\n    var visibilityCache = new Map();\n    var anyFocusable = getFocusableNodes(entries, visibilityCache);\n    var innerElements = anyFocusable.filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    });\n    if (!innerElements[0]) {\n        return undefined;\n    }\n    var outerNodes = getFocusableNodes([commonParent], visibilityCache).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var orderedInnerElements = reorderNodes(outerNodes, innerElements);\n    // collect inner focusable and separately tabbables\n    var innerFocusables = orderedInnerElements.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var innerTabbable = orderedInnerElements.filter(function (_a) {\n        var tabIndex = _a.tabIndex;\n        return tabIndex >= 0;\n    }).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var newId = newFocus(innerFocusables, innerTabbable, outerNodes, activeElement, lastNode);\n    if (newId === NEW_FOCUS) {\n        var focusNode = \n        // first try only tabbable, and the fallback to all focusable, as long as at least one element should be picked for focus\n        pickAutofocus(anyFocusable, innerTabbable, allParentAutofocusables(entries, visibilityCache)) ||\n            pickAutofocus(anyFocusable, innerFocusables, allParentAutofocusables(entries, visibilityCache));\n        if (focusNode) {\n            return { node: focusNode };\n        }\n        else {\n            console.warn('focus-lock: cannot find any node to move focus into');\n            return undefined;\n        }\n    }\n    if (newId === undefined) {\n        return newId;\n    }\n    return orderedInnerElements[newId];\n};\n","import { getAllAffectedNodes } from './utils/all-affected';\nimport { isGuard, isNotAGuard } from './utils/is';\nimport { getTopCommonParent } from './utils/parenting';\nimport { orderByTabIndex } from './utils/tabOrder';\nimport { getFocusables } from './utils/tabUtils';\n/**\n * traverses all related nodes (including groups) returning a list of all nodes(outer and internal) with meta information\n * This is low-level API!\n * @returns list of focusable elements inside a given top(!) node.\n * @see {@link getFocusableNodes} providing a simpler API\n */\nexport var expandFocusableNodes = function (topNode) {\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(topNode, topNode, entries);\n    var outerNodes = orderByTabIndex(getFocusables([commonParent], true), true, true);\n    var innerElements = getFocusables(entries, false);\n    return outerNodes.map(function (_a) {\n        var node = _a.node, index = _a.index;\n        return ({\n            node: node,\n            index: index,\n            lockItem: innerElements.indexOf(node) >= 0,\n            guard: isGuard(node),\n        });\n    });\n};\n","export var focusOn = function (target, focusOptions) {\n    if (!target) {\n        // not clear how, but is possible https://github.com/theKashey/focus-lock/issues/53\n        return;\n    }\n    if ('focus' in target) {\n        target.focus(focusOptions);\n    }\n    if ('contentWindow' in target && target.contentWindow) {\n        target.contentWindow.focus();\n    }\n};\n","import { focusOn } from './commands';\nimport { focusSolver } from './focusSolver';\nvar guardCount = 0;\nvar lockDisabled = false;\n/**\n * The main functionality of the focus-lock package\n *\n * Contains focus at a given node.\n * The last focused element will help to determine which element(first or last) should be focused.\n * The found element will be focused.\n *\n * This is one time action (move), not a persistent focus-lock\n *\n * HTML markers (see {@link import('./constants').FOCUS_AUTO} constants) can control autofocus\n * @see {@link focusSolver} for the same functionality without autofocus\n */\nexport var moveFocusInside = function (topNode, lastNode, options) {\n    if (options === void 0) { options = {}; }\n    var focusable = focusSolver(topNode, lastNode);\n    // global local side effect to countain recursive lock activation and resolve focus-fighting\n    if (lockDisabled) {\n        return;\n    }\n    if (focusable) {\n        /** +FOCUS-FIGHTING prevention **/\n        if (guardCount > 2) {\n            // we have recursive entered back the lock activation\n            console.error('FocusLock: focus-fighting detected. Only one focus management system could be active. ' +\n                'See https://github.com/theKashey/focus-lock/#focus-fighting');\n            lockDisabled = true;\n            setTimeout(function () {\n                lockDisabled = false;\n            }, 1);\n            return;\n        }\n        guardCount++;\n        focusOn(focusable.node, options.focusOptions);\n        guardCount--;\n    }\n};\n","import { getTabbableNodes } from './utils/DOMutils';\nfunction weakRef(value) {\n    if (!value)\n        return null;\n    // #68 Safari 14.1 dont have it yet\n    // FIXME: remove in 2025\n    if (typeof WeakRef === 'undefined') {\n        return function () { return value || null; };\n    }\n    var w = value ? new WeakRef(value) : null;\n    return function () { return (w === null || w === void 0 ? void 0 : w.deref()) || null; };\n}\nexport var recordElementLocation = function (element) {\n    if (!element) {\n        return null;\n    }\n    var stack = [];\n    var currentElement = element;\n    while (currentElement && currentElement !== document.body) {\n        stack.push({\n            current: weakRef(currentElement),\n            parent: weakRef(currentElement.parentElement),\n            left: weakRef(currentElement.previousElementSibling),\n            right: weakRef(currentElement.nextElementSibling),\n        });\n        currentElement = currentElement.parentElement;\n    }\n    return {\n        element: weakRef(element),\n        stack: stack,\n        ownerDocument: element.ownerDocument,\n    };\n};\nvar restoreFocusTo = function (location) {\n    var _a, _b, _c, _d, _e;\n    if (!location) {\n        return undefined;\n    }\n    var stack = location.stack, ownerDocument = location.ownerDocument;\n    var visibilityCache = new Map();\n    for (var _i = 0, stack_1 = stack; _i < stack_1.length; _i++) {\n        var line = stack_1[_i];\n        var parent_1 = (_a = line.parent) === null || _a === void 0 ? void 0 : _a.call(line);\n        // is it still here?\n        if (parent_1 && ownerDocument.contains(parent_1)) {\n            var left = (_b = line.left) === null || _b === void 0 ? void 0 : _b.call(line);\n            var savedCurrent = line.current();\n            var current = parent_1.contains(savedCurrent) ? savedCurrent : undefined;\n            var right = (_c = line.right) === null || _c === void 0 ? void 0 : _c.call(line);\n            var focusables = getTabbableNodes([parent_1], visibilityCache);\n            var aim = \n            // that is element itself\n            (_e = (_d = current !== null && current !== void 0 ? current : \n            // or something in it's place\n            left === null || left === void 0 ? void 0 : left.nextElementSibling) !== null && _d !== void 0 ? _d : \n            // or somebody to the right, still close enough\n            right) !== null && _e !== void 0 ? _e : \n            // or somebody to the left, something?\n            left;\n            while (aim) {\n                for (var _f = 0, focusables_1 = focusables; _f < focusables_1.length; _f++) {\n                    var focusable = focusables_1[_f];\n                    if (aim === null || aim === void 0 ? void 0 : aim.contains(focusable.node)) {\n                        return focusable.node;\n                    }\n                }\n                aim = aim.nextElementSibling;\n            }\n            if (focusables.length) {\n                // if parent contains a focusable - move there\n                return focusables[0].node;\n            }\n        }\n    }\n    // nothing matched\n    return undefined;\n};\n/**\n * Captures the current focused element to restore focus as close as possible in the future\n * Handles situations where the focused element is removed from the DOM or no longer focusable\n * moving focus to the closest focusable element\n * @param targetElement - element where focus should be restored\n * @returns a function returning a new element to focus\n */\nexport var captureFocusRestore = function (targetElement) {\n    var location = recordElementLocation(targetElement);\n    return function () {\n        return restoreFocusTo(location);\n    };\n};\n","import { focusOn } from './commands';\nimport { getTabbableNodes, contains, getFocusableNodes } from './utils/DOMutils';\nimport { asArray } from './utils/array';\n/**\n * for a given `element` in a given `scope` returns focusable siblings\n * @param element - base element\n * @param scope - common parent. Can be document, but better to narrow it down for performance reasons\n * @returns {prev,next} - references to a focusable element before and after\n * @returns undefined - if operation is not applicable\n */\nexport var getRelativeFocusable = function (element, scope, useTabbables) {\n    if (!element || !scope) {\n        console.error('no element or scope given');\n        return {};\n    }\n    var shards = asArray(scope);\n    if (shards.every(function (shard) { return !contains(shard, element); })) {\n        console.error('Active element is not contained in the scope');\n        return {};\n    }\n    var focusables = useTabbables\n        ? getTabbableNodes(shards, new Map())\n        : getFocusableNodes(shards, new Map());\n    var current = focusables.findIndex(function (_a) {\n        var node = _a.node;\n        return node === element;\n    });\n    if (current === -1) {\n        // an edge case, when anchor element is not found\n        return undefined;\n    }\n    return {\n        prev: focusables[current - 1],\n        next: focusables[current + 1],\n        first: focusables[0],\n        last: focusables[focusables.length - 1],\n    };\n};\nvar getBoundary = function (shards, useTabbables) {\n    var set = useTabbables\n        ? getTabbableNodes(asArray(shards), new Map())\n        : getFocusableNodes(asArray(shards), new Map());\n    return {\n        first: set[0],\n        last: set[set.length - 1],\n    };\n};\nvar defaultOptions = function (options) {\n    return Object.assign({\n        scope: document.body,\n        cycle: true,\n        onlyTabbable: true,\n    }, options);\n};\nvar moveFocus = function (fromElement, options, cb) {\n    if (options === void 0) { options = {}; }\n    var newOptions = defaultOptions(options);\n    var solution = getRelativeFocusable(fromElement, newOptions.scope, newOptions.onlyTabbable);\n    if (!solution) {\n        return;\n    }\n    var target = cb(solution, newOptions.cycle);\n    if (target) {\n        focusOn(target.node, newOptions.focusOptions);\n    }\n};\n/**\n * focuses next element in the tab-order\n * @param fromElement - common parent to scope active element search or tab cycle order\n * @param {FocusNextOptions} [options] - focus options\n */\nexport var focusNextElement = function (fromElement, options) {\n    if (options === void 0) { options = {}; }\n    moveFocus(fromElement, options, function (_a, cycle) {\n        var next = _a.next, first = _a.first;\n        return next || (cycle && first);\n    });\n};\n/**\n * focuses prev element in the tab order\n * @param fromElement - common parent to scope active element search or tab cycle order\n * @param {FocusNextOptions} [options] - focus options\n */\nexport var focusPrevElement = function (fromElement, options) {\n    if (options === void 0) { options = {}; }\n    moveFocus(fromElement, options, function (_a, cycle) {\n        var prev = _a.prev, last = _a.last;\n        return prev || (cycle && last);\n    });\n};\nvar pickBoundary = function (scope, options, what) {\n    var _a;\n    var boundary = getBoundary(scope, (_a = options.onlyTabbable) !== null && _a !== void 0 ? _a : true);\n    var node = boundary[what];\n    if (node) {\n        focusOn(node.node, options.focusOptions);\n    }\n};\n/**\n * focuses first element in the tab-order\n * @param {FocusNextOptions} options - focus options\n */\nexport var focusFirstElement = function (scope, options) {\n    if (options === void 0) { options = {}; }\n    pickBoundary(scope, options, 'first');\n};\n/**\n * focuses last element in the tab order\n * @param {FocusNextOptions} options - focus options\n */\nexport var focusLastElement = function (scope, options) {\n    if (options === void 0) { options = {}; }\n    pickBoundary(scope, options, 'last');\n};\n"],"names":["FOCUS_GROUP","FOCUS_DISABLED","FOCUS_ALLOW","FOCUS_AUTO","FOCUS_NO_AUTOFOCUS","toArray","a","ret","i","asArray","getFirst","isElementHidden","node","computedStyle","getParentNode","isTopNode","isInert","isVisibleUncached","checkParent","isVisibleCached","visibilityCache","cached","result","isAutoFocusAllowedUncached","isAutoFocusAllowed","isAutoFocusAllowedCached","cache","getDataset","isHTMLButtonElement","isHTMLInputElement","isRadioElement","notHiddenInput","attribute","isGuard","_a","isNotAGuard","isDefined","x","tabSort","b","aTab","bTab","tabDiff","indexDiff","getTabIndex","orderByTabIndex","nodes","filterNegative","keepGuards","index","tabIndex","data","tabbables","queryTabbables","queryGuardTabbables","getFocusablesWithShadowDom","parent","withGuards","acc","child","getFocusablesWithIFrame","getFocusables","parents","focusableWithShadowDom","focusableWithIframes","getParentAutofocusables","parentFocus","filterFocusable","filterAutoFocusable","getTabbableNodes","topNodes","getFocusableNodes","parentAutofocusables","topNode","contains","scope","element","iframeBody","filterNested","contained","l","j","position","_","getTopParent","getAllAffectedNodes","currentNode","group","safeProbe","cb","getActiveElement","inDocument","activeElement","focusInFrame","frame","focusInsideIframe","focusInside","focusIsHidden","findSelectedRadio","el","correctNode","correctNodes","resultSet","pickFirstFocus","pickFocusable","NEW_FOCUS","newFocus","innerNodes","innerTabbables","outerNodes","lastNode","cnt","firstFocus","lastFocus","isOnGuard","activeIndex","lastIndex","lastNodeInside","firstNodeIndex","lastNodeIndex","correctedNodes","correctedIndex","correctedIndexDiff","returnFirstNode","returnLastNode","findAutoFocused","autoFocusables","autofocus","pickAutofocus","nodesIndexes","orderedNodes","groups","autoFocusable","getParents","getCommonParent","nodeA","nodeB","parentsA","parentsB","currentParent","getTopCommonParent","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","entry","subEntry","common","allParentAutofocusables","entries","reorderNodes","srcNodes","dstNodes","remap","entity","focusSolver","commonParent","anyFocusable","innerElements","orderedInnerElements","innerFocusables","innerTabbable","newId","focusNode","expandFocusableNodes","focusOn","target","focusOptions","guardCount","lockDisabled","moveFocusInside","options","focusable","weakRef","value","w","recordElementLocation","stack","currentElement","restoreFocusTo","location","_b","_c","_d","_e","ownerDocument","_i","stack_1","line","parent_1","left","savedCurrent","current","right","focusables","aim","_f","focusables_1","captureFocusRestore","targetElement","getRelativeFocusable","useTabbables","shards","shard","getBoundary","set","defaultOptions","moveFocus","fromElement","newOptions","solution","focusNextElement","cycle","next","first","focusPrevElement","prev","last","pickBoundary","what","boundary","focusFirstElement","focusLastElement"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22]}