{"version":3,"file":"7810.b7140b54b1ab6fae1b67.bundle.js","mappings":"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","sources":["webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/array.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/is.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/tabOrder.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/tabUtils.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/tabbables.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/DOMutils.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/getActiveElement.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/safe.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/all-affected.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/focusInside.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/commands.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/correctFocus.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/firstFocus.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/solver.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/auto-focus.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/utils/parenting.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/focusSolver.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/moveFocusInside.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/return-focus.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/sibling.js","webpack://@hm/react/./node_modules/react-focus-lock/dist/es2015/util.js","webpack://@hm/react/./node_modules/react-focus-lock/dist/es2015/Trap.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/focusables.js","webpack://@hm/react/./node_modules/focus-lock/dist/es2015/focusIsHidden.js","webpack://@hm/react/./node_modules/react-clientside-effect/lib/index.es.js"],"sourcesContent":["/*\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","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","/**\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 { 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","/**\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","export var safeProbe = function (cb) {\n    try {\n        return cb();\n    }\n    catch (e) {\n        return undefined;\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","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","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 { 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 currentFocusableIndex = activeElement !== undefined ? correctedNodes.indexOf(activeElement) : -1;\n    var previousFocusableIndex = lastNode ? correctedNodes.indexOf(lastNode) : currentFocusableIndex;\n    var tabbableNodes = correctedNodes.filter(function (node) { return node.tabIndex >= 0; });\n    var currentTabbableIndex = activeElement !== undefined ? tabbableNodes.indexOf(activeElement) : -1;\n    var previousTabbableIndex = lastNode ? tabbableNodes.indexOf(lastNode) : currentTabbableIndex;\n    var focusIndexDiff = currentTabbableIndex >= 0 && previousTabbableIndex >= 0\n        ? // old/new are tabbables, measure distance in tabbable space\n            previousTabbableIndex - currentTabbableIndex\n        : // or else measure in focusable space\n            previousFocusableIndex - currentFocusableIndex;\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(focusIndexDiff) > 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 { 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","export function deferAction(action) {\n  setTimeout(action, 1);\n}\nexport var inlineProp = function inlineProp(name, value) {\n  var obj = {};\n  obj[name] = value;\n  return obj;\n};\nexport var extractRef = function extractRef(ref) {\n  return ref && 'current' in ref ? ref.current : ref;\n};","import React from 'react';\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-clientside-effect';\nimport { moveFocusInside, focusInside, focusIsHidden, expandFocusableNodes, getFocusableNodes, focusNextElement, focusPrevElement, focusFirstElement, focusLastElement, captureFocusRestore } from 'focus-lock';\nimport { deferAction, extractRef } from './util';\nimport { mediumFocus, mediumBlur, mediumEffect } from './medium';\nvar focusOnBody = function focusOnBody() {\n  return document && document.activeElement === document.body;\n};\nvar isFreeFocus = function isFreeFocus() {\n  return focusOnBody() || focusIsHidden();\n};\nvar lastActiveTrap = null;\nvar lastActiveFocus = null;\nvar tryRestoreFocus = function tryRestoreFocus() {\n  return null;\n};\nvar lastPortaledElement = null;\nvar focusWasOutsideWindow = false;\nvar windowFocused = false;\nvar defaultWhitelist = function defaultWhitelist() {\n  return true;\n};\nvar focusWhitelisted = function focusWhitelisted(activeElement) {\n  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);\n};\nvar recordPortal = function recordPortal(observerNode, portaledElement) {\n  lastPortaledElement = {\n    observerNode: observerNode,\n    portaledElement: portaledElement\n  };\n};\nvar focusIsPortaledPair = function focusIsPortaledPair(element) {\n  return lastPortaledElement && lastPortaledElement.portaledElement === element;\n};\nfunction autoGuard(startIndex, end, step, allNodes) {\n  var lastGuard = null;\n  var i = startIndex;\n  do {\n    var item = allNodes[i];\n    if (item.guard) {\n      if (item.node.dataset.focusAutoGuard) {\n        lastGuard = item;\n      }\n    } else if (item.lockItem) {\n      if (i !== startIndex) {\n        return;\n      }\n      lastGuard = null;\n    } else {\n      break;\n    }\n  } while ((i += step) !== end);\n  if (lastGuard) {\n    lastGuard.node.tabIndex = 0;\n  }\n}\nvar focusWasOutside = function focusWasOutside(crossFrameOption) {\n  if (crossFrameOption) {\n    return Boolean(focusWasOutsideWindow);\n  }\n  return focusWasOutsideWindow === 'meanwhile';\n};\nvar checkInHost = function checkInHost(check, el, boundary) {\n  return el && (el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) || el.parentNode && checkInHost(check, el.parentNode, boundary));\n};\nvar withinHost = function withinHost(activeElement, workingArea) {\n  return workingArea.some(function (area) {\n    return checkInHost(activeElement, area, area);\n  });\n};\nvar getNodeFocusables = function getNodeFocusables(nodes) {\n  return getFocusableNodes(nodes, new Map());\n};\nvar isNotFocusable = function isNotFocusable(node) {\n  return !getNodeFocusables([node.parentNode]).some(function (el) {\n    return el.node === node;\n  });\n};\nvar activateTrap = function activateTrap() {\n  var result = false;\n  if (lastActiveTrap) {\n    var _lastActiveTrap = lastActiveTrap,\n      observed = _lastActiveTrap.observed,\n      persistentFocus = _lastActiveTrap.persistentFocus,\n      autoFocus = _lastActiveTrap.autoFocus,\n      shards = _lastActiveTrap.shards,\n      crossFrame = _lastActiveTrap.crossFrame,\n      focusOptions = _lastActiveTrap.focusOptions,\n      noFocusGuards = _lastActiveTrap.noFocusGuards;\n    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;\n    if (focusOnBody() && lastActiveFocus && lastActiveFocus !== document.body) {\n      if (!document.body.contains(lastActiveFocus) || isNotFocusable(lastActiveFocus)) {\n        var newTarget = tryRestoreFocus();\n        if (newTarget) {\n          newTarget.focus();\n        }\n      }\n    }\n    var activeElement = document && document.activeElement;\n    if (workingNode) {\n      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));\n      var shouldForceRestoreFocus = function shouldForceRestoreFocus() {\n        if (!focusWasOutside(crossFrame) || !noFocusGuards || !lastActiveFocus || windowFocused) {\n          return false;\n        }\n        var nodes = getNodeFocusables(workingArea);\n        var lastIndex = nodes.findIndex(function (_ref) {\n          var node = _ref.node;\n          return node === lastActiveFocus;\n        });\n        return lastIndex === 0 || lastIndex === nodes.length - 1;\n      };\n      if (!activeElement || focusWhitelisted(activeElement)) {\n        if (persistentFocus || shouldForceRestoreFocus() || !isFreeFocus() || !lastActiveFocus && autoFocus) {\n          if (workingNode && !(focusInside(workingArea) || activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement, workingNode))) {\n            if (document && !lastActiveFocus && activeElement && !autoFocus) {\n              if (activeElement.blur) {\n                activeElement.blur();\n              }\n              document.body.focus();\n            } else {\n              result = moveFocusInside(workingArea, lastActiveFocus, {\n                focusOptions: focusOptions\n              });\n              lastPortaledElement = {};\n            }\n          }\n          lastActiveFocus = document && document.activeElement;\n          if (lastActiveFocus !== document.body) {\n            tryRestoreFocus = captureFocusRestore(lastActiveFocus);\n          }\n          focusWasOutsideWindow = false;\n        }\n      }\n      if (document && activeElement !== document.activeElement && document.querySelector('[data-focus-auto-guard]')) {\n        var newActiveElement = document && document.activeElement;\n        var allNodes = expandFocusableNodes(workingArea);\n        var focusedIndex = allNodes.map(function (_ref2) {\n          var node = _ref2.node;\n          return node;\n        }).indexOf(newActiveElement);\n        if (focusedIndex > -1) {\n          allNodes.filter(function (_ref3) {\n            var guard = _ref3.guard,\n              node = _ref3.node;\n            return guard && node.dataset.focusAutoGuard;\n          }).forEach(function (_ref4) {\n            var node = _ref4.node;\n            return node.removeAttribute('tabIndex');\n          });\n          autoGuard(focusedIndex, allNodes.length, +1, allNodes);\n          autoGuard(focusedIndex, -1, -1, allNodes);\n        }\n      }\n    }\n  }\n  return result;\n};\nvar onTrap = function onTrap(event) {\n  if (activateTrap() && event) {\n    event.stopPropagation();\n    event.preventDefault();\n  }\n};\nvar onBlur = function onBlur() {\n  return deferAction(activateTrap);\n};\nvar onFocus = function onFocus(event) {\n  var source = event.target;\n  var currentNode = event.currentTarget;\n  if (!currentNode.contains(source)) {\n    recordPortal(currentNode, source);\n  }\n};\nvar FocusWatcher = function FocusWatcher() {\n  return null;\n};\nvar FocusTrap = function FocusTrap(_ref5) {\n  var children = _ref5.children;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    onBlur: onBlur,\n    onFocus: onFocus\n  }, children);\n};\nFocusTrap.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node.isRequired\n} : {};\nvar onWindowFocus = function onWindowFocus() {\n  windowFocused = true;\n};\nvar onWindowBlur = function onWindowBlur() {\n  windowFocused = false;\n  focusWasOutsideWindow = 'just';\n  deferAction(function () {\n    focusWasOutsideWindow = 'meanwhile';\n  });\n};\nvar attachHandler = function attachHandler() {\n  document.addEventListener('focusin', onTrap);\n  document.addEventListener('focusout', onBlur);\n  window.addEventListener('focus', onWindowFocus);\n  window.addEventListener('blur', onWindowBlur);\n};\nvar detachHandler = function detachHandler() {\n  document.removeEventListener('focusin', onTrap);\n  document.removeEventListener('focusout', onBlur);\n  window.removeEventListener('focus', onWindowFocus);\n  window.removeEventListener('blur', onWindowBlur);\n};\nfunction reducePropsToState(propsList) {\n  return propsList.filter(function (_ref6) {\n    var disabled = _ref6.disabled;\n    return !disabled;\n  });\n}\nvar focusLockAPI = {\n  moveFocusInside: moveFocusInside,\n  focusInside: focusInside,\n  focusNextElement: focusNextElement,\n  focusPrevElement: focusPrevElement,\n  focusFirstElement: focusFirstElement,\n  focusLastElement: focusLastElement,\n  captureFocusRestore: captureFocusRestore\n};\nfunction handleStateChangeOnClient(traps) {\n  var trap = traps.slice(-1)[0];\n  if (trap && !lastActiveTrap) {\n    attachHandler();\n  }\n  var lastTrap = lastActiveTrap;\n  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;\n  lastActiveTrap = trap;\n  if (lastTrap && !sameTrap) {\n    lastTrap.onDeactivation();\n    if (!traps.filter(function (_ref7) {\n      var id = _ref7.id;\n      return id === lastTrap.id;\n    }).length) {\n      lastTrap.returnFocus(!trap);\n    }\n  }\n  if (trap) {\n    lastActiveFocus = null;\n    if (!sameTrap || lastTrap.observed !== trap.observed) {\n      trap.onActivation(focusLockAPI);\n    }\n    activateTrap(true);\n    deferAction(activateTrap);\n  } else {\n    detachHandler();\n    lastActiveFocus = null;\n  }\n}\nmediumFocus.assignSyncMedium(onFocus);\nmediumBlur.assignMedium(onBlur);\nmediumEffect.assignMedium(function (cb) {\n  return cb(focusLockAPI);\n});\nexport default withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);","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","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 _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _defineProperty from '@babel/runtime/helpers/esm/defineProperty';\nimport React, { PureComponent } from 'react';\n\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof reducePropsToState !== 'function') {\n      throw new Error('Expected reducePropsToState to be a function.');\n    }\n\n    if (typeof handleStateChangeOnClient !== 'function') {\n      throw new Error('Expected handleStateChangeOnClient to be a function.');\n    }\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof WrappedComponent !== 'function') {\n        throw new Error('Expected WrappedComponent to be a React component.');\n      }\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n      handleStateChangeOnClient(state);\n    }\n\n    var SideEffect = /*#__PURE__*/function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      }\n\n      // Try to use displayName of wrapped component\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.componentDidMount = function componentDidMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return /*#__PURE__*/React.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    return SideEffect;\n  };\n}\n\nexport default withSideEffect;\n"],"names":["toArray","a","ret","Array","length","i","asArray","isArray","getFirst","getParentNode","node","parentNode","nodeType","Node","DOCUMENT_FRAGMENT_NODE","host","isTopNode","document","DOCUMENT_NODE","isVisibleCached","visibilityCache","cached","get","undefined","result","checkParent","ELEMENT_NODE","computedStyle","window","getComputedStyle","getPropertyValue","isElementHidden","hasAttribute","isInert","isVisibleUncached","bind","set","isAutoFocusAllowedCached","cache","isAutoFocusAllowed","isAutoFocusAllowedUncached","getDataset","dataset","isHTMLInputElement","tagName","isRadioElement","type","attribute","getAttribute","FOCUS_NO_AUTOFOCUS","includes","isGuard","_a","Boolean","focusGuard","isNotAGuard","isDefined","x","tabSort","b","aTab","Math","max","tabIndex","bTab","tabDiff","indexDiff","index","orderByTabIndex","nodes","filterNegative","keepGuards","map","getTabIndex","filter","data","sort","queryTabbables","join","queryGuardTabbables","concat","getFocusablesWithShadowDom","parent","withGuards","shadowRoot","children","reduce","acc","child","matches","getFocusables","parents","focusableWithShadowDom","focusableWithIframes","apply","HTMLIFrameElement","contentDocument","body","getFocusablesWithIFrame","querySelectorAll","filterFocusable","isHTMLButtonElement","disabled","notHiddenInput","filterAutoFocusable","Map","getTabbableNodes","topNodes","getFocusableNodes","contains","scope","element","Object","getPrototypeOf","call","some","iframeBody","getActiveElement","inDocument","activeElement","cb","contentWindow","e","safeProbe","getTopParent","getAllAffectedNodes","currentNode","group","FOCUS_GROUP","push","contained","Set","l","j","position","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","add","DOCUMENT_POSITION_CONTAINS","_","has","filterNested","FOCUS_DISABLED","focusInside","topNode","ownerDocument","frame","focusInFrame","focusInsideIframe","focusOn","target","focusOptions","focus","correctNode","name","el","checked","findSelectedRadio","pickFirstFocus","pickFocusable","indexOf","NEW_FOCUS","pickAutofocus","nodesIndexes","orderedNodes","groups","autoFocusables","autoFocusable","autofocus","getParents","getCommonParent","nodeA","nodeB","parentsA","parentsB","currentParent","getTopCommonParent","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","forEach","entry","subEntry","common","allParentAutofocusables","entries","parentFocus","FOCUS_AUTO","parentAutofocusables","focusSolver","lastNode","commonParent","anyFocusable","innerElements","srcNodes","dstNodes","remap","outerNodes","orderedInnerElements","entity","innerFocusables","innerTabbable","newId","innerNodes","innerTabbables","cnt","firstFocus","lastFocus","isOnGuard","activeIndex","lastIndex","lastNodeInside","resultSet","firstNodeIndex","lastNodeIndex","correctedNodes","currentFocusableIndex","previousFocusableIndex","tabbableNodes","currentTabbableIndex","previousTabbableIndex","focusIndexDiff","returnFirstNode","returnLastNode","abs","newFocus","focusNode","console","warn","guardCount","lockDisabled","moveFocusInside","options","focusable","error","setTimeout","weakRef","value","WeakRef","w","deref","captureFocusRestore","targetElement","location","stack","currentElement","current","parentElement","left","previousElementSibling","right","nextElementSibling","recordElementLocation","_b","_c","_d","_e","_i","stack_1","line","parent_1","savedCurrent","focusables","aim","_f","focusables_1","restoreFocusTo","moveFocus","fromElement","newOptions","assign","cycle","onlyTabbable","defaultOptions","solution","useTabbables","shards","every","shard","findIndex","prev","next","first","last","getRelativeFocusable","pickBoundary","what","deferAction","action","extractRef","ref","focusOnBody","lastActiveTrap","lastActiveFocus","tryRestoreFocus","lastPortaledElement","focusWasOutsideWindow","windowFocused","defaultWhitelist","autoGuard","startIndex","end","step","allNodes","lastGuard","item","guard","focusAutoGuard","lockItem","checkInHost","check","boundary","getNodeFocusables","activateTrap","_lastActiveTrap","observed","persistentFocus","autoFocus","crossFrame","noFocusGuards","workingNode","portaledElement","newTarget","workingArea","whiteList","focusWhitelisted","_ref","shouldForceRestoreFocus","FOCUS_ALLOW","focusIsHidden","area","withinHost","blur","querySelector","newActiveElement","focusedIndex","_ref2","_ref3","_ref4","removeAttribute","onTrap","event","stopPropagation","preventDefault","onBlur","onWindowFocus","onWindowBlur","focusLockAPI","focusNextElement","focusPrevElement","focusFirstElement","focusLastElement","medium","assignSyncMedium","source","currentTarget","observerNode","assignMedium","reducePropsToState","handleStateChangeOnClient","propsList","_ref6","traps","trap","slice","addEventListener","lastTrap","sameTrap","id","onDeactivation","_ref7","returnFocus","onActivation","removeEventListener","WrappedComponent","state","mountedInstances","emitChange","instance","props","SideEffect","_PureComponent","this","arguments","peek","_proto","prototype","componentDidMount","componentDidUpdate","componentWillUnmount","splice","render","PureComponent","displayName","getDisplayName"],"sourceRoot":""}