{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack:///./node_modules/warning/warning.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/react-focus-lock/dist/es2015/FocusGuard.js","webpack:///./node_modules/react-focus-lock/dist/es2015/medium.js","webpack:///./node_modules/react-focus-lock/dist/es2015/Lock.js","webpack:///./node_modules/focus-lock/dist/es2015/constants.js","webpack:///./node_modules/react-clientside-effect/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack:///./node_modules/react-clientside-effect/lib/index.es.js","webpack:///./node_modules/react-clientside-effect/node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/react-clientside-effect/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/array.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/all-affected.js","webpack:///./node_modules/focus-lock/dist/es2015/focusInside.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/correctFocus.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/firstFocus.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/is.js","webpack:///./node_modules/focus-lock/dist/es2015/solver.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/tabOrder.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/tabUtils.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/tabbables.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/DOMutils.js","webpack:///./node_modules/focus-lock/dist/es2015/utils/parenting.js","webpack:///./node_modules/focus-lock/dist/es2015/focusMerge.js","webpack:///./node_modules/focus-lock/dist/es2015/setFocus.js","webpack:///./node_modules/focus-lock/dist/es2015/index.js","webpack:///./node_modules/react-focus-lock/dist/es2015/util.js","webpack:///./node_modules/react-focus-lock/dist/es2015/Trap.js","webpack:///./node_modules/focus-lock/dist/es2015/focusIsHidden.js","webpack:///./node_modules/focus-lock/dist/es2015/focusables.js","webpack:///./node_modules/react-focus-lock/dist/es2015/Combination.js","webpack:///./node_modules/react-focus-lock/dist/es2015/index.js","webpack:///./node_modules/use-sidecar/dist/es2015/medium.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/medium.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/UI.js","webpack:///./node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack:///./node_modules/use-sidecar/dist/es2015/exports.js","webpack:///./node_modules/get-nonce/dist/es2015/index.js","webpack:///./node_modules/react-style-singleton/dist/es2015/singleton.js","webpack:///./node_modules/react-style-singleton/dist/es2015/component.js","webpack:///./node_modules/react-style-singleton/dist/es2015/hook.js","webpack:///./node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack:///./node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/Combination.js","webpack:///./node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack:///./node_modules/use-callback-ref/dist/es2015/useRef.js","webpack:///./node_modules/use-callback-ref/dist/es2015/assignRef.js"],"names":["_extends","Object","assign","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","_objectWithoutPropertiesLoose","excluded","sourceKeys","keys","indexOf","warning","module","exports","__assign","t","s","n","p","__rest","e","getOwnPropertySymbols","hiddenGuard","width","height","padding","overflow","position","top","left","_ref","children","style","propTypes","defaultProps","mediumFocus","currentTarget","mediumBlur","mediumEffect","mediumSidecar","async","emptyArray","FocusLock","props","parentRef","_extends2","_React$useState","realObserved","setObserved","observed","isActive","originalFocusedElement","disabled","noFocusGuards","persistentFocus","crossFrame","autoFocus","group","allowTextSelection","className","whiteList","_props$shards","shards","_props$as","as","Container","_props$lockProps","lockProps","containerProps","SideCar","sideCar","shouldReturnFocus","returnFocus","onActivationCallback","onActivation","onDeactivationCallback","onDeactivation","id","current","document","activeElement","allowDefer","Boolean","focus","focusOptions","undefined","Promise","resolve","then","onFocus","event","useMedium","onBlur","setObserveNode","newObserved","hasLeadingGuards","hasTailingGuards","mergedRef","useMergeRef","tabIndex","ref","_setPrototypeOf","o","setPrototypeOf","__proto__","reducePropsToState","handleStateChangeOnClient","WrappedComponent","state","mountedInstances","emitChange","map","instance","obj","value","SideEffect","_PureComponent","subClass","superClass","create","constructor","peek","_proto","componentDidMount","push","componentDidUpdate","componentWillUnmount","index","splice","render","createElement","displayName","name","getDisplayName","defineProperty","enumerable","configurable","writable","toArray","a","ret","Array","asArray","isArray","getTopParent","node","parentNode","getAllAffectedNodes","filter","reduce","acc","currentNode","getAttribute","nodes","contained","Set","l","j","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","add","DOCUMENT_POSITION_CONTAINS","_","has","filterNested","querySelectorAll","focusInsideIframe","topNode","some","focusInside","dataset","focusGuard","result","contains","isRadio","tagName","type","correctNode","el","checked","findSelectedRadio","pickFirstFocus","pickFocusable","isVisible","nodeType","DOCUMENT_NODE","computedStyle","window","getComputedStyle","getPropertyValue","DOCUMENT_FRAGMENT_NODE","host","isGuard","isNotAGuard","isDefined","x","newFocus","innerNodes","outerNodes","lastNode","cnt","firstFocus","lastFocus","isOnGuard","resultSet","activeIndex","lastIndex","lastNodeInside","indexDiff","firstNodeIndex","lastNodeIndex","correctedNodes","forEach","correctedIndexDiff","returnFirstNode","returnLastNode","Math","abs","tabSort","b","tabDiff","orderByTabIndex","filterNegative","keepGuards","data","sort","queryTabbables","join","queryGuardTabbables","getFocusables","parents","withGuards","parent","concat","filterFocusable","notHiddenInput","getTabbableNodes","topNodes","getAllTabbableNodes","parentAutofocusables","parentFocus","getParents","getCommonParent","nodeA","nodeB","parentsA","parentsB","currentParent","getTopCommonParent","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","entry","subEntry","common","getFocusMerge","entries","commonParent","anyFocusable","innerElements","_a","srcNodes","dstNodes","remap","autoFocusables","orderedInnerElements","Map","entity","set","get","newId","autoFocusable","allParentAutofocusables","autofocus","guardCount","lockDisabled","focusable","console","error","setTimeout","contentWindow","deferAction","action","setImmediate","body","lastActiveTrap","lastActiveFocus","lastPortaledElement","focusWasOutsideWindow","defaultWhitelist","autoGuard","startIndex","end","step","allNodes","lastGuard","item","guard","focusAutoGuard","lockItem","extractRef","element","_lastActiveTrap","workingNode","portaledElement","workingArea","focusWhitelisted","blur","newActiveElement","focusedIndex","_ref2","_ref3","removeAttribute","onTrap","stopPropagation","preventDefault","observerNode","onWindowBlur","assignSyncMedium","assignMedium","cb","moveFocusInside","propsList","_ref5","traps","trap","slice","addEventListener","lastTrap","sameTrap","_ref6","removeEventListener","FocusLockCombination","ItoI","innerCreateMedium","defaults","middleware","buffer","assigned","read","Error","cbs","pendingQueue","executeQueue","cycle","createMedium","createSidecarMedium","options","medium","ssr","effectCar","nothing","RemoveScroll","onScrollCapture","onWheelCapture","onTouchMoveCapture","callbacks","setCallbacks","forwardProps","removeScrollBar","enabled","noIsolation","inert","allowPinchZoom","_b","rest","containerRef","lockRef","only","classNames","fullWidth","zeroRight","currentNonce","Target","isSideCarExport","makeStyleTag","tag","nonce","setAttribute","stylesheetSingleton","counter","stylesheet","css","styleSheet","cssText","appendChild","createTextNode","head","getElementsByTagName","insertStyleTag","remove","removeChild","styleSingleton","sheet","useStyle","styles","zeroGap","right","gap","parse","parseInt","getGapWidth","gapMode","offsets","cs","getOffset","documentWidth","documentElement","clientWidth","windowWidth","innerWidth","max","getStyles","allowRelative","important","RemoveScrollBar","setGap","noRelative","noImportant","locationCouldBeScrolled","axis","elementCouldBeScrolled","getScrollVariables","overflowY","overflowX","elementCouldBeVScrolled","elementCouldBeHScrolled","scrollTop","scrollHeight","clientHeight","scrollLeft","scrollWidth","getHScrollVariables","passiveSupported","err","nonPassive","passive","getTouchXY","changedTouches","clientX","clientY","getDeltaXY","deltaX","deltaY","generateStyle","idCounter","lockStack","exported","shouldPreventQueue","touchStartRef","activeAxis","Style","lastProps","classList","allow_1","shouldCancelEvent","touches","currentAxis","touch","touchStart","moveDirection","canBeScrolledInMainDirection","cancelingAxis","endTarget","sourceDelta","noOverscroll","delta","targetInLock","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","elementScroll","handleScroll","shouldPrevent","_event","sourceEvent","y","should","shardNodes","shouldCancel","scrollTouchStart","scrollWheel","scrollTouchMove","inst","ReactRemoveScroll","useMergeRefs","refs","defaultValue","initialValue","callback","newValue","assignRef","facade","last"],"mappings":"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","file":"8.e4cc413c.js","sourcesContent":["export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar __DEV__ = process.env.NODE_ENV !== 'production';\n\nvar warning = function() {};\n\nif (__DEV__) {\n  var printWarning = function printWarning(format, args) {\n    var len = arguments.length;\n    args = new Array(len > 1 ? len - 1 : 0);\n    for (var key = 1; key < len; key++) {\n      args[key - 1] = arguments[key];\n    }\n    var argIndex = 0;\n    var message = 'Warning: ' +\n      format.replace(/%s/g, function() {\n        return args[argIndex++];\n      });\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  }\n\n  warning = function(condition, format, args) {\n    var len = arguments.length;\n    args = new Array(len > 2 ? len - 2 : 0);\n    for (var key = 2; key < len; key++) {\n      args[key - 2] = arguments[key];\n    }\n    if (format === undefined) {\n      throw new Error(\n          '`warning(condition, format, ...args)` requires a warning ' +\n          'message argument'\n      );\n    }\n    if (!condition) {\n      printWarning.apply(null, [format].concat(args));\n    }\n  };\n}\n\nmodule.exports = warning;\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import * as React from 'react';\nimport PropTypes from 'prop-types';\nexport var hiddenGuard = {\n  width: '1px',\n  height: '0px',\n  padding: 0,\n  overflow: 'hidden',\n  position: 'fixed',\n  top: '1px',\n  left: '1px'\n};\n\nvar InFocusGuard = function InFocusGuard(_ref) {\n  var children = _ref.children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }), children, children && /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-last\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }));\n};\n\nInFocusGuard.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node\n} : {};\nInFocusGuard.defaultProps = {\n  children: null\n};\nexport default InFocusGuard;","import { createMedium, createSidecarMedium } from 'use-sidecar';\nexport var mediumFocus = createMedium({}, function (_ref) {\n  var target = _ref.target,\n      currentTarget = _ref.currentTarget;\n  return {\n    target: target,\n    currentTarget: currentTarget\n  };\n});\nexport var mediumBlur = createMedium();\nexport var mediumEffect = createMedium();\nexport var mediumSidecar = createSidecarMedium({\n  async: true\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { node, bool, string, any, arrayOf, oneOfType, object, func } from 'prop-types';\nimport * as constants from 'focus-lock/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { hiddenGuard } from './FocusGuard';\nimport { mediumFocus, mediumBlur, mediumSidecar } from './medium';\nvar emptyArray = [];\nvar FocusLock = /*#__PURE__*/React.forwardRef(function FocusLockUI(props, parentRef) {\n  var _extends2;\n\n  var _React$useState = React.useState(),\n      realObserved = _React$useState[0],\n      setObserved = _React$useState[1];\n\n  var observed = React.useRef();\n  var isActive = React.useRef(false);\n  var originalFocusedElement = React.useRef(null);\n  var children = props.children,\n      disabled = props.disabled,\n      noFocusGuards = props.noFocusGuards,\n      persistentFocus = props.persistentFocus,\n      crossFrame = props.crossFrame,\n      autoFocus = props.autoFocus,\n      allowTextSelection = props.allowTextSelection,\n      group = props.group,\n      className = props.className,\n      whiteList = props.whiteList,\n      _props$shards = props.shards,\n      shards = _props$shards === void 0 ? emptyArray : _props$shards,\n      _props$as = props.as,\n      Container = _props$as === void 0 ? 'div' : _props$as,\n      _props$lockProps = props.lockProps,\n      containerProps = _props$lockProps === void 0 ? {} : _props$lockProps,\n      SideCar = props.sideCar,\n      shouldReturnFocus = props.returnFocus,\n      onActivationCallback = props.onActivation,\n      onDeactivationCallback = props.onDeactivation;\n\n  var _React$useState2 = React.useState({}),\n      id = _React$useState2[0]; // SIDE EFFECT CALLBACKS\n\n\n  var onActivation = React.useCallback(function () {\n    originalFocusedElement.current = originalFocusedElement.current || document && document.activeElement;\n\n    if (observed.current && onActivationCallback) {\n      onActivationCallback(observed.current);\n    }\n\n    isActive.current = true;\n  }, [onActivationCallback]);\n  var onDeactivation = React.useCallback(function () {\n    isActive.current = false;\n\n    if (onDeactivationCallback) {\n      onDeactivationCallback(observed.current);\n    }\n  }, [onDeactivationCallback]);\n  var returnFocus = React.useCallback(function (allowDefer) {\n    var current = originalFocusedElement.current;\n\n    if (Boolean(shouldReturnFocus) && current && current.focus) {\n      var focusOptions = typeof shouldReturnFocus === 'object' ? shouldReturnFocus : undefined;\n      originalFocusedElement.current = null;\n\n      if (allowDefer) {\n        // React might return focus after update\n        // it's safer to defer the action\n        Promise.resolve().then(function () {\n          return current.focus(focusOptions);\n        });\n      } else {\n        current.focus(focusOptions);\n      }\n    }\n  }, [shouldReturnFocus]); // MEDIUM CALLBACKS\n\n  var onFocus = React.useCallback(function (event) {\n    if (isActive.current) {\n      mediumFocus.useMedium(event);\n    }\n  }, []);\n  var onBlur = mediumBlur.useMedium; // REF PROPAGATION\n  // not using real refs due to race conditions\n\n  var setObserveNode = React.useCallback(function (newObserved) {\n    if (observed.current !== newObserved) {\n      observed.current = newObserved;\n      setObserved(newObserved);\n    }\n  }, []);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof allowTextSelection !== 'undefined') {\n      // eslint-disable-next-line no-console\n      console.warn('React-Focus-Lock: allowTextSelection is deprecated and enabled by default');\n    }\n\n    React.useEffect(function () {\n      if (!observed.current) {\n        // eslint-disable-next-line no-console\n        console.error('FocusLock: could not obtain ref to internal node');\n      }\n    }, []);\n  }\n\n  var lockProps = _extends((_extends2 = {}, _extends2[constants.FOCUS_DISABLED] = disabled && 'disabled', _extends2[constants.FOCUS_GROUP] = group, _extends2), containerProps);\n\n  var hasLeadingGuards = noFocusGuards !== true;\n  var hasTailingGuards = hasLeadingGuards && noFocusGuards !== 'tail';\n  var mergedRef = useMergeRefs([parentRef, setObserveNode]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, hasLeadingGuards && [/*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }),\n  /*#__PURE__*/\n  // nearest focus guard\n  React.createElement(\"div\", {\n    key: \"guard-nearest\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 1,\n    style: hiddenGuard\n  }) // first tabbed element guard\n  ], !disabled && /*#__PURE__*/React.createElement(SideCar, {\n    id: id,\n    sideCar: mediumSidecar,\n    observed: realObserved,\n    disabled: disabled,\n    persistentFocus: persistentFocus,\n    crossFrame: crossFrame,\n    autoFocus: autoFocus,\n    whiteList: whiteList,\n    shards: shards,\n    onActivation: onActivation,\n    onDeactivation: onDeactivation,\n    returnFocus: returnFocus\n  }), /*#__PURE__*/React.createElement(Container, _extends({\n    ref: mergedRef\n  }, lockProps, {\n    className: className,\n    onBlur: onBlur,\n    onFocus: onFocus\n  }), children), hasTailingGuards && /*#__PURE__*/React.createElement(\"div\", {\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }));\n});\nFocusLock.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: node,\n  disabled: bool,\n  returnFocus: oneOfType([bool, object]),\n  noFocusGuards: bool,\n  allowTextSelection: bool,\n  autoFocus: bool,\n  persistentFocus: bool,\n  crossFrame: bool,\n  group: string,\n  className: string,\n  whiteList: func,\n  shards: arrayOf(any),\n  as: oneOfType([string, func, object]),\n  lockProps: object,\n  onActivation: func,\n  onDeactivation: func,\n  sideCar: any.isRequired\n} : {};\nFocusLock.defaultProps = {\n  children: undefined,\n  disabled: false,\n  returnFocus: false,\n  noFocusGuards: false,\n  autoFocus: true,\n  persistentFocus: false,\n  crossFrame: true,\n  allowTextSelection: undefined,\n  group: undefined,\n  className: undefined,\n  whiteList: undefined,\n  shards: undefined,\n  as: 'div',\n  lockProps: {},\n  onActivation: undefined,\n  onDeactivation: undefined\n};\nexport default FocusLock;","export var FOCUS_GROUP = 'data-focus-lock';\nexport var FOCUS_DISABLED = 'data-focus-lock-disabled';\nexport var FOCUS_ALLOW = 'data-no-focus-lock';\nexport var FOCUS_AUTO = 'data-autofocus-inside';\n","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\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","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}","export 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]); };\n","import { FOCUS_DISABLED, FOCUS_GROUP } from '../constants';\nimport { asArray, toArray } from './array';\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            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        }\n    }\n    return nodes.filter(function (_, index) { return !contained.has(index); });\n};\nvar getTopParent = function (node) {\n    return node.parentNode ? getTopParent(node.parentNode) : node;\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(\"[\" + FOCUS_GROUP + \"=\\\"\" + group + \"\\\"]:not([\" + FOCUS_DISABLED + \"=\\\"disabled\\\"])\")))\n            : [currentNode]));\n        return acc;\n    }, []);\n};\n","import { getAllAffectedNodes } from './utils/all-affected';\nimport { toArray } from './utils/array';\nvar focusInFrame = function (frame) { return frame === document.activeElement; };\nvar focusInsideIframe = function (topNode) {\n    return Boolean(toArray(topNode.querySelectorAll('iframe')).some(function (node) { return focusInFrame(node); }));\n};\nexport var focusInside = function (topNode) {\n    var activeElement = document && document.activeElement;\n    if (!activeElement || (activeElement.dataset && activeElement.dataset.focusGuard)) {\n        return false;\n    }\n    return getAllAffectedNodes(topNode).reduce(function (result, node) { return result || node.contains(activeElement) || focusInsideIframe(node); }, false);\n};\n","var isRadio = function (node) { return node.tagName === 'INPUT' && node.type === 'radio'; };\nvar findSelectedRadio = function (node, nodes) {\n    return nodes\n        .filter(isRadio)\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 (isRadio(node) && node.name) {\n        return findSelectedRadio(node, nodes);\n    }\n    return node;\n};\nexport var correctNodes = function (nodes) {\n    var resultSet = new Set();\n    nodes.forEach(function (node) { return resultSet.add(correctNode(node, nodes)); });\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, index) {\n    if (nodes.length > 1) {\n        return nodes.indexOf(correctNode(nodes[index], nodes));\n    }\n    return index;\n};\n","var isElementHidden = function (computedStyle) {\n    if (!computedStyle || !computedStyle.getPropertyValue) {\n        return false;\n    }\n    return (computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden');\n};\nexport var isVisible = function (node) {\n    return !node ||\n        node === document ||\n        (node && node.nodeType === Node.DOCUMENT_NODE) ||\n        (!isElementHidden(window.getComputedStyle(node, null)) &&\n            isVisible(node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n                ? node.parentNode.host\n                : node.parentNode));\n};\nexport var notHiddenInput = function (node) {\n    return !((node.tagName === 'INPUT' || node.tagName === 'BUTTON') && (node.type === 'hidden' || node.disabled));\n};\nexport var isGuard = function (node) { return Boolean(node && node.dataset && node.dataset.focusGuard); };\nexport var isNotAGuard = function (node) { return !isGuard(node); };\nexport var isDefined = function (x) { return Boolean(x); };\n","import { correctNodes } from './utils/correctFocus';\nimport { pickFocusable } from './utils/firstFocus';\nimport { isGuard } from './utils/is';\nexport var NEW_FOCUS = 'NEW_FOCUS';\nexport var newFocus = function (innerNodes, 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    if (innerNodes.indexOf(activeElement) >= 0) {\n        return undefined;\n    }\n    var activeIndex = outerNodes.indexOf(activeElement);\n    var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;\n    var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;\n    var indexDiff = activeIndex - lastIndex;\n    var firstNodeIndex = outerNodes.indexOf(firstFocus);\n    var lastNodeIndex = outerNodes.indexOf(lastFocus);\n    var correctedNodes = correctNodes(outerNodes);\n    var correctedIndexDiff = correctedNodes.indexOf(activeElement) - (lastNode ? correctedNodes.indexOf(lastNode) : activeIndex);\n    var returnFirstNode = pickFocusable(innerNodes, 0);\n    var returnLastNode = pickFocusable(innerNodes, cnt - 1);\n    if (activeIndex === -1 || lastNodeInside === -1) {\n        return NEW_FOCUS;\n    }\n    if (!indexDiff && lastNodeInside >= 0) {\n        return lastNodeInside;\n    }\n    if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnLastNode;\n    }\n    if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnFirstNode;\n    }\n    if (indexDiff && Math.abs(correctedIndexDiff) > 1) {\n        return lastNodeInside;\n    }\n    if (activeIndex <= firstNodeIndex) {\n        return returnLastNode;\n    }\n    if (activeIndex > lastNodeIndex) {\n        return returnFirstNode;\n    }\n    if (indexDiff) {\n        if (Math.abs(indexDiff) > 1) {\n            return lastNodeInside;\n        }\n        return (cnt + lastNodeInside + indexDiff) % cnt;\n    }\n    return undefined;\n};\n","import { toArray } from './array';\nexport var tabSort = function (a, b) {\n    var tabDiff = a.tabIndex - b.tabIndex;\n    var indexDiff = a.index - b.index;\n    if (tabDiff) {\n        if (!a.tabIndex) {\n            return 1;\n        }\n        if (!b.tabIndex) {\n            return -1;\n        }\n    }\n    return tabDiff || indexDiff;\n};\nexport var orderByTabIndex = function (nodes, filterNegative, keepGuards) {\n    return toArray(nodes)\n        .map(function (node, index) { return ({\n        node: node,\n        index: index,\n        tabIndex: keepGuards && node.tabIndex === -1 ? ((node.dataset || {}).focusGuard ? 0 : -1) : node.tabIndex,\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 = queryTabbables + \", [data-focus-guard]\";\nexport var getFocusables = function (parents, withGuards) {\n    return parents.reduce(function (acc, parent) {\n        return acc.concat(toArray(parent.querySelectorAll(withGuards ? queryGuardTabbables : queryTabbables)), parent.parentNode\n            ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function (node) { return node === parent; })\n            : []);\n    }, []);\n};\nexport var getParentAutofocusables = function (parent) {\n    var parentFocus = parent.querySelectorAll(\"[\" + FOCUS_AUTO + \"]\");\n    return toArray(parentFocus)\n        .map(function (node) { return getFocusables([node]); })\n        .reduce(function (acc, nodes) { return acc.concat(nodes); }, []);\n};\n","export var tabbables = [\n    'button:enabled',\n    'select:enabled',\n    'textarea:enabled',\n    'input:enabled',\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 { isVisible, notHiddenInput } from './is';\nimport { orderByTabIndex } from './tabOrder';\nimport { getFocusables, getParentAutofocusables } from './tabUtils';\nexport var filterFocusable = function (nodes) {\n    return toArray(nodes)\n        .filter(function (node) { return isVisible(node); })\n        .filter(function (node) { return notHiddenInput(node); });\n};\nexport var getTabbableNodes = function (topNodes, withGuards) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards)), true, withGuards);\n};\nexport var getAllTabbableNodes = function (topNodes) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes)), false);\n};\nexport var parentAutofocusables = function (topNode) {\n    return filterFocusable(getParentAutofocusables(topNode));\n};\n","import { asArray } from './array';\nimport { parentAutofocusables } from './DOMutils';\nvar getParents = function (node, parents) {\n    if (parents === void 0) { parents = []; }\n    parents.push(node);\n    if (node.parentNode) {\n        getParents(node.parentNode, parents);\n    }\n    return parents;\n};\nexport var getCommonParent = function (nodeA, nodeB) {\n    var parentsA = getParents(nodeA);\n    var parentsB = getParents(nodeB);\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 || common.contains(topCommon)) {\n                    topCommon = common;\n                }\n                else {\n                    topCommon = getCommonParent(common, topCommon);\n                }\n            }\n        });\n    });\n    return topCommon;\n};\nexport var allParentAutofocusables = function (entries) {\n    return entries.reduce(function (acc, node) { return acc.concat(parentAutofocusables(node)); }, []);\n};\n","import { NEW_FOCUS, newFocus } from './solver';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { getAllTabbableNodes, getTabbableNodes } from './utils/DOMutils';\nimport { pickFirstFocus } from './utils/firstFocus';\nimport { isDefined, isNotAGuard } from './utils/is';\nimport { allParentAutofocusables, getTopCommonParent } from './utils/parenting';\nvar findAutoFocused = function (autoFocusables) { return function (node) {\n    return node.autofocus || (node.dataset && !!node.dataset.autofocus) || autoFocusables.indexOf(node) >= 0;\n}; };\nvar reorderNodes = function (srcNodes, dstNodes) {\n    var remap = new Map();\n    dstNodes.forEach(function (entity) { return remap.set(entity.node, entity); });\n    return srcNodes.map(function (node) { return remap.get(node); }).filter(isDefined);\n};\nexport var getFocusMerge = function (topNode, lastNode) {\n    var activeElement = (document && document.activeElement);\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);\n    var anyFocusable = getAllTabbableNodes(entries);\n    var innerElements = getTabbableNodes(entries).filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    });\n    if (!innerElements[0]) {\n        innerElements = anyFocusable;\n        if (!innerElements[0]) {\n            return undefined;\n        }\n    }\n    var outerNodes = getAllTabbableNodes([commonParent]).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var orderedInnerElements = reorderNodes(outerNodes, innerElements);\n    var innerNodes = orderedInnerElements.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var newId = newFocus(innerNodes, outerNodes, activeElement, lastNode);\n    if (newId === NEW_FOCUS) {\n        var autoFocusable = anyFocusable\n            .map(function (_a) {\n            var node = _a.node;\n            return node;\n        })\n            .filter(findAutoFocused(allParentAutofocusables(entries)));\n        return {\n            node: autoFocusable && autoFocusable.length ? pickFirstFocus(autoFocusable) : pickFirstFocus(innerNodes),\n        };\n    }\n    if (newId === undefined) {\n        return newId;\n    }\n    return orderedInnerElements[newId];\n};\n","import { getFocusMerge } from './focusMerge';\nexport var focusOn = function (target) {\n    target.focus();\n    if ('contentWindow' in target && target.contentWindow) {\n        target.contentWindow.focus();\n    }\n};\nvar guardCount = 0;\nvar lockDisabled = false;\nexport var setFocus = function (topNode, lastNode) {\n    var focusable = getFocusMerge(topNode, lastNode);\n    if (lockDisabled) {\n        return;\n    }\n    if (focusable) {\n        if (guardCount > 2) {\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);\n        guardCount--;\n    }\n};\n","import * as constants from './constants';\nimport { getFocusabledIn } from './focusables';\nimport { focusInside } from './focusInside';\nimport { focusIsHidden } from './focusIsHidden';\nimport { getFocusMerge as focusMerge } from './focusMerge';\nimport { setFocus } from './setFocus';\nimport { focusNextElement, focusPrevElement } from './sibling';\nimport tabHook from './tabHook';\nimport { getAllAffectedNodes } from './utils/all-affected';\nexport { tabHook, focusInside, focusIsHidden, focusMerge, getFocusabledIn, constants, getAllAffectedNodes, focusNextElement, focusPrevElement, };\nexport default setFocus;\n","export function deferAction(action) {\n  // Hidding setImmediate from Webpack to avoid inserting polyfill\n  var _window = window,\n      setImmediate = _window.setImmediate;\n\n  if (typeof setImmediate !== 'undefined') {\n    setImmediate(action);\n  } else {\n    setTimeout(action, 1);\n  }\n}\nexport var inlineProp = function inlineProp(name, value) {\n  var obj = {};\n  obj[name] = value;\n  return obj;\n};","import * as React from 'react';\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-clientside-effect';\nimport moveFocusInside, { focusInside, focusIsHidden, getFocusabledIn } from 'focus-lock';\nimport { deferAction } from './util';\nimport { mediumFocus, mediumBlur, mediumEffect } from './medium';\n\nvar focusOnBody = function focusOnBody() {\n  return document && document.activeElement === document.body;\n};\n\nvar isFreeFocus = function isFreeFocus() {\n  return focusOnBody() || focusIsHidden();\n};\n\nvar lastActiveTrap = null;\nvar lastActiveFocus = null;\nvar lastPortaledElement = null;\nvar focusWasOutsideWindow = false;\n\nvar defaultWhitelist = function defaultWhitelist() {\n  return true;\n};\n\nvar focusWhitelisted = function focusWhitelisted(activeElement) {\n  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);\n};\n\nvar recordPortal = function recordPortal(observerNode, portaledElement) {\n  lastPortaledElement = {\n    observerNode: observerNode,\n    portaledElement: portaledElement\n  };\n};\n\nvar focusIsPortaledPair = function focusIsPortaledPair(element) {\n  return lastPortaledElement && lastPortaledElement.portaledElement === element;\n};\n\nfunction autoGuard(startIndex, end, step, allNodes) {\n  var lastGuard = null;\n  var i = startIndex;\n\n  do {\n    var item = allNodes[i];\n\n    if (item.guard) {\n      if (item.node.dataset.focusAutoGuard) {\n        lastGuard = item;\n      }\n    } else if (item.lockItem) {\n      if (i !== startIndex) {\n        // we will tab to the next element\n        return;\n      }\n\n      lastGuard = null;\n    } else {\n      break;\n    }\n  } while ((i += step) !== end);\n\n  if (lastGuard) {\n    lastGuard.node.tabIndex = 0;\n  }\n}\n\nvar extractRef = function extractRef(ref) {\n  return ref && 'current' in ref ? ref.current : ref;\n};\n\nvar focusWasOutside = function focusWasOutside(crossFrameOption) {\n  if (crossFrameOption) {\n    // with cross frame return true for any value\n    return Boolean(focusWasOutsideWindow);\n  } // in other case return only of focus went a while aho\n\n\n  return focusWasOutsideWindow === 'meanwhile';\n};\n\nvar activateTrap = function activateTrap() {\n  var result = false;\n\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    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;\n    var activeElement = document && document.activeElement;\n\n    if (workingNode) {\n      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));\n\n      if (!activeElement || focusWhitelisted(activeElement)) {\n        if (persistentFocus || focusWasOutside(crossFrame) || !isFreeFocus() || !lastActiveFocus && autoFocus) {\n          if (workingNode && !(focusInside(workingArea) || focusIsPortaledPair(activeElement, workingNode))) {\n            if (document && !lastActiveFocus && activeElement && !autoFocus) {\n              // Check if blur() exists, which is missing on certain elements on IE\n              if (activeElement.blur) {\n                activeElement.blur();\n              }\n\n              document.body.focus();\n            } else {\n              result = moveFocusInside(workingArea, lastActiveFocus);\n              lastPortaledElement = {};\n            }\n          }\n\n          focusWasOutsideWindow = false;\n          lastActiveFocus = document && document.activeElement;\n        }\n      }\n\n      if (document) {\n        var newActiveElement = document && document.activeElement;\n        var allNodes = getFocusabledIn(workingArea);\n        var focusedIndex = allNodes.map(function (_ref) {\n          var node = _ref.node;\n          return node;\n        }).indexOf(newActiveElement);\n\n        if (focusedIndex > -1) {\n          // remove old focus\n          allNodes.filter(function (_ref2) {\n            var guard = _ref2.guard,\n                node = _ref2.node;\n            return guard && node.dataset.focusAutoGuard;\n          }).forEach(function (_ref3) {\n            var node = _ref3.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\n  return result;\n};\n\nvar onTrap = function onTrap(event) {\n  if (activateTrap() && event) {\n    // prevent scroll jump\n    event.stopPropagation();\n    event.preventDefault();\n  }\n};\n\nvar onBlur = function onBlur() {\n  return deferAction(activateTrap);\n};\n\nvar onFocus = function onFocus(event) {\n  // detect portal\n  var source = event.target;\n  var currentNode = event.currentTarget;\n\n  if (!currentNode.contains(source)) {\n    recordPortal(currentNode, source);\n  }\n};\n\nvar FocusWatcher = function FocusWatcher() {\n  return null;\n};\n\nvar FocusTrap = function FocusTrap(_ref4) {\n  var children = _ref4.children;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    onBlur: onBlur,\n    onFocus: onFocus\n  }, children);\n};\n\nFocusTrap.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node.isRequired\n} : {};\n\nvar onWindowBlur = function onWindowBlur() {\n  focusWasOutsideWindow = 'just'; // using setTimeout to set  this variable after React/sidecar reaction\n\n  setTimeout(function () {\n    focusWasOutsideWindow = 'meanwhile';\n  }, 0);\n};\n\nvar attachHandler = function attachHandler() {\n  document.addEventListener('focusin', onTrap, true);\n  document.addEventListener('focusout', onBlur);\n  window.addEventListener('blur', onWindowBlur);\n};\n\nvar detachHandler = function detachHandler() {\n  document.removeEventListener('focusin', onTrap, true);\n  document.removeEventListener('focusout', onBlur);\n  window.removeEventListener('blur', onWindowBlur);\n};\n\nfunction reducePropsToState(propsList) {\n  return propsList.filter(function (_ref5) {\n    var disabled = _ref5.disabled;\n    return !disabled;\n  });\n}\n\nfunction handleStateChangeOnClient(traps) {\n  var trap = traps.slice(-1)[0];\n\n  if (trap && !lastActiveTrap) {\n    attachHandler();\n  }\n\n  var lastTrap = lastActiveTrap;\n  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;\n  lastActiveTrap = trap;\n\n  if (lastTrap && !sameTrap) {\n    lastTrap.onDeactivation(); // return focus only of last trap was removed\n\n    if (!traps.filter(function (_ref6) {\n      var id = _ref6.id;\n      return id === lastTrap.id;\n    }).length) {\n      // allow defer is no other trap is awaiting restore\n      lastTrap.returnFocus(!trap);\n    }\n  }\n\n  if (trap) {\n    lastActiveFocus = null;\n\n    if (!sameTrap || lastTrap.observed !== trap.observed) {\n      trap.onActivation();\n    }\n\n    activateTrap(true);\n    deferAction(activateTrap);\n  } else {\n    detachHandler();\n    lastActiveFocus = null;\n  }\n} // bind medium\n\n\nmediumFocus.assignSyncMedium(onFocus);\nmediumBlur.assignMedium(onBlur);\nmediumEffect.assignMedium(function (cb) {\n  return cb({\n    moveFocusInside: moveFocusInside,\n    focusInside: focusInside\n  });\n});\nexport default withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);","import { FOCUS_ALLOW } from './constants';\nimport { toArray } from './utils/array';\nexport var focusIsHidden = function () {\n    return document &&\n        toArray(document.querySelectorAll(\"[\" + FOCUS_ALLOW + \"]\")).some(function (node) { return node.contains(document.activeElement); });\n};\n","import { getAllAffectedNodes } from './utils/all-affected';\nimport { getTabbableNodes } from './utils/DOMutils';\nimport { isGuard, isNotAGuard } from './utils/is';\nimport { getTopCommonParent } from './utils/parenting';\nexport var getFocusabledIn = function (topNode) {\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(topNode, topNode, entries);\n    var outerNodes = getTabbableNodes([commonParent], true);\n    var innerElements = getTabbableNodes(entries)\n        .filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    })\n        .map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\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 _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport FocusLockUI from './Lock';\nimport FocusTrap from './Trap';\n/* that would be a BREAKING CHANGE!\n// delaying sidecar execution till the first usage\nconst RequireSideCar = (props) => {\n  // eslint-disable-next-line global-require\n  const SideCar = require('./Trap').default;\n  return <SideCar {...props} />;\n};\n*/\n\nvar FocusLockCombination = /*#__PURE__*/React.forwardRef(function FocusLockUICombination(props, ref) {\n  return /*#__PURE__*/React.createElement(FocusLockUI, _extends({\n    sideCar: FocusTrap,\n    ref: ref\n  }, props));\n});\n\nvar _ref = FocusLockUI.propTypes || {},\n    sideCar = _ref.sideCar,\n    propTypes = _objectWithoutPropertiesLoose(_ref, [\"sideCar\"]);\n\nFocusLockCombination.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\nexport default FocusLockCombination;","import FocusLock from './Combination';\nexport * from './UI';\nexport default FocusLock;","import * as tslib_1 from \"tslib\";\nfunction ItoI(a) {\n    return a;\n}\nfunction innerCreateMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    var buffer = [];\n    var assigned = false;\n    var medium = {\n        read: function () {\n            if (assigned) {\n                throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');\n            }\n            if (buffer.length) {\n                return buffer[buffer.length - 1];\n            }\n            return defaults;\n        },\n        useMedium: function (data) {\n            var item = middleware(data, assigned);\n            buffer.push(item);\n            return function () {\n                buffer = buffer.filter(function (x) { return x !== item; });\n            };\n        },\n        assignSyncMedium: function (cb) {\n            assigned = true;\n            while (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n            }\n            buffer = {\n                push: function (x) { return cb(x); },\n                filter: function () { return buffer; },\n            };\n        },\n        assignMedium: function (cb) {\n            assigned = true;\n            var pendingQueue = [];\n            if (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n                pendingQueue = buffer;\n            }\n            var executeQueue = function () {\n                var cbs = pendingQueue;\n                pendingQueue = [];\n                cbs.forEach(cb);\n            };\n            var cycle = function () { return Promise.resolve().then(executeQueue); };\n            cycle();\n            buffer = {\n                push: function (x) {\n                    pendingQueue.push(x);\n                    cycle();\n                },\n                filter: function (filter) {\n                    pendingQueue = pendingQueue.filter(filter);\n                    return buffer;\n                },\n            };\n        },\n    };\n    return medium;\n}\nexport function createMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    return innerCreateMedium(defaults, middleware);\n}\nexport function createSidecarMedium(options) {\n    if (options === void 0) { options = {}; }\n    var medium = innerCreateMedium(null);\n    medium.options = tslib_1.__assign({ async: true, ssr: false }, options);\n    return medium;\n}\n","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { fullWidthClassName, zeroRightClassName } from 'react-remove-scroll-bar/constants';\nimport { effectCar } from './medium';\nimport { useMergeRefs } from 'use-callback-ref';\nvar nothing = function () {\n    return;\n};\n/**\n * Removes scrollbar from the page and contain the scroll within the Lock\n */\nvar RemoveScroll = React.forwardRef(function (props, parentRef) {\n    var ref = React.useRef(null);\n    var _a = React.useState({\n        onScrollCapture: nothing,\n        onWheelCapture: nothing,\n        onTouchMoveCapture: nothing\n    }), callbacks = _a[0], setCallbacks = _a[1];\n    var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? 'div' : _b, rest = tslib_1.__rest(props, [\"forwardProps\", \"children\", \"className\", \"removeScrollBar\", \"enabled\", \"shards\", \"sideCar\", \"noIsolation\", \"inert\", \"allowPinchZoom\", \"as\"]);\n    var SideCar = sideCar;\n    var containerRef = useMergeRefs([\n        ref,\n        parentRef\n    ]);\n    var containerProps = tslib_1.__assign({}, rest, callbacks);\n    return (React.createElement(React.Fragment, null,\n        enabled && (React.createElement(SideCar, { sideCar: effectCar, removeScrollBar: removeScrollBar, shards: shards, noIsolation: noIsolation, inert: inert, setCallbacks: setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref })),\n        forwardProps ? (React.cloneElement(React.Children.only(children), tslib_1.__assign({}, containerProps, { ref: containerRef }))) : (React.createElement(Container, tslib_1.__assign({}, containerProps, { className: className, ref: containerRef }), children))));\n});\nRemoveScroll.defaultProps = {\n    enabled: true,\n    removeScrollBar: true,\n    inert: false\n};\nRemoveScroll.classNames = {\n    fullWidth: fullWidthClassName,\n    zeroRight: zeroRightClassName\n};\nexport { RemoveScroll };\n","export var zeroRightClassName = 'right-scroll-bar-position';\nexport var fullWidthClassName = 'width-before-scroll-bar';\nexport var noScrollbarsClassName = 'with-scroll-bars-hidden';\nexport var removedBarSizeVariable = '--removed-body-scroll-bar-size';\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nvar SideCar = function (_a) {\n    var sideCar = _a.sideCar, rest = tslib_1.__rest(_a, [\"sideCar\"]);\n    if (!sideCar) {\n        throw new Error('Sidecar: please provide `sideCar` property to import the right car');\n    }\n    var Target = sideCar.read();\n    if (!Target) {\n        throw new Error('Sidecar medium not found');\n    }\n    return React.createElement(Target, tslib_1.__assign({}, rest));\n};\nSideCar.isSideCarExport = true;\nexport function exportSidecar(medium, exported) {\n    medium.useMedium(exported);\n    return SideCar;\n}\n","var currentNonce;\nexport var setNonce = function (nonce) {\n    currentNonce = nonce;\n};\nexport var getNonce = function () {\n    if (currentNonce) {\n        return currentNonce;\n    }\n    if (typeof __webpack_nonce__ !== 'undefined') {\n        return __webpack_nonce__;\n    }\n    return undefined;\n};\n","import { getNonce } from \"get-nonce\";\nfunction makeStyleTag() {\n    if (!document)\n        return null;\n    var tag = document.createElement('style');\n    tag.type = 'text/css';\n    var nonce = getNonce();\n    if (nonce) {\n        tag.setAttribute('nonce', nonce);\n    }\n    return tag;\n}\nfunction injectStyles(tag, css) {\n    if (tag.styleSheet) {\n        tag.styleSheet.cssText = css;\n    }\n    else {\n        tag.appendChild(document.createTextNode(css));\n    }\n}\nfunction insertStyleTag(tag) {\n    var head = document.head || document.getElementsByTagName('head')[0];\n    head.appendChild(tag);\n}\nexport var stylesheetSingleton = function () {\n    var counter = 0;\n    var stylesheet = null;\n    return {\n        add: function (style) {\n            if (counter == 0) {\n                if (stylesheet = makeStyleTag()) {\n                    injectStyles(stylesheet, style);\n                    insertStyleTag(stylesheet);\n                }\n            }\n            counter++;\n        },\n        remove: function () {\n            counter--;\n            if (!counter && stylesheet) {\n                stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);\n                stylesheet = null;\n            }\n        }\n    };\n};\n","import { styleHookSingleton } from \"./hook\";\nexport var styleSingleton = function () {\n    var useStyle = styleHookSingleton();\n    var Sheet = function (_a) {\n        var styles = _a.styles;\n        useStyle(styles);\n        return null;\n    };\n    return Sheet;\n};\n","import * as React from 'react';\nimport { stylesheetSingleton } from \"./singleton\";\nexport var styleHookSingleton = function () {\n    var sheet = stylesheetSingleton();\n    return function (styles) {\n        React.useEffect(function () {\n            sheet.add(styles);\n            return function () {\n                sheet.remove();\n            };\n        }, []);\n    };\n};\n","export var zeroGap = {\n    left: 0,\n    top: 0,\n    right: 0,\n    gap: 0,\n};\nvar parse = function (x) { return parseInt(x || '', 10) || 0; };\nvar getOffset = function (gapMode) {\n    var cs = window.getComputedStyle(document.body);\n    var left = cs[gapMode === 'padding' ? 'paddingLeft' : 'marginLeft'];\n    var top = cs[gapMode === 'padding' ? 'paddingTop' : 'marginTop'];\n    var right = cs[gapMode === 'padding' ? 'paddingRight' : 'marginRight'];\n    return [\n        parse(left),\n        parse(top),\n        parse(right),\n    ];\n};\nexport var getGapWidth = function (gapMode) {\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    if (typeof window === 'undefined') {\n        return zeroGap;\n    }\n    var offsets = getOffset(gapMode);\n    var documentWidth = document.documentElement.clientWidth;\n    var windowWidth = window.innerWidth;\n    return {\n        left: offsets[0],\n        top: offsets[1],\n        right: offsets[2],\n        gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0]),\n    };\n};\n","import * as React from 'react';\nimport { styleSingleton } from 'react-style-singleton';\nimport { getGapWidth } from './utils';\nimport { fullWidthClassName, zeroRightClassName, noScrollbarsClassName, removedBarSizeVariable } from \"./constants\";\nvar Style = styleSingleton();\nvar getStyles = function (_a, allowRelative, gapMode, important) {\n    var left = _a.left, top = _a.top, right = _a.right, gap = _a.gap;\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    return \"\\n  .\" + noScrollbarsClassName + \" {\\n   overflow: hidden \" + important + \";\\n   padding-right: \" + gap + \"px \" + important + \";\\n  }\\n  body {\\n    overflow: hidden \" + important + \";\\n    \" + [\n        allowRelative && \"position: relative \" + important + \";\",\n        gapMode === 'margin' && \"\\n    padding-left: \" + left + \"px;\\n    padding-top: \" + top + \"px;\\n    padding-right: \" + right + \"px;\\n    margin-left:0;\\n    margin-top:0;\\n    margin-right: \" + gap + \"px \" + important + \";\\n    \",\n        gapMode === 'padding' && \"padding-right: \" + gap + \"px \" + important + \";\",\n    ].filter(Boolean).join('') + \"\\n  }\\n  \\n  .\" + zeroRightClassName + \" {\\n    right: \" + gap + \"px \" + important + \";\\n  }\\n  \\n  .\" + fullWidthClassName + \" {\\n    margin-right: \" + gap + \"px \" + important + \";\\n  }\\n  \\n  .\" + zeroRightClassName + \" .\" + zeroRightClassName + \" {\\n    right: 0 \" + important + \";\\n  }\\n  \\n  .\" + fullWidthClassName + \" .\" + fullWidthClassName + \" {\\n    margin-right: 0 \" + important + \";\\n  }\\n  \\n  body {\\n    \" + removedBarSizeVariable + \": \" + gap + \"px;\\n  }\\n\";\n};\nexport var RemoveScrollBar = function (props) {\n    var _a = React.useState(getGapWidth(props.gapMode)), gap = _a[0], setGap = _a[1];\n    React.useEffect(function () {\n        setGap(getGapWidth(props.gapMode));\n    }, [props.gapMode]);\n    var noRelative = props.noRelative, noImportant = props.noImportant, _b = props.gapMode, gapMode = _b === void 0 ? 'margin' : _b;\n    return React.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? \"!important\" : '') });\n};\n","var elementCouldBeVScrolled = function (node) {\n    var styles = window.getComputedStyle(node);\n    return (styles.overflowY !== 'hidden' && // not-not-scrollable\n        !(styles.overflowY === styles.overflowX && styles.overflowY === 'visible') // scrollable\n    );\n};\nvar elementCouldBeHScrolled = function (node) {\n    var styles = window.getComputedStyle(node);\n    return (styles.overflowX !== 'hidden' && // not-not-scrollable\n        !(styles.overflowY === styles.overflowX && styles.overflowX === 'visible') // scrollable\n    );\n};\nexport var locationCouldBeScrolled = function (axis, node) {\n    var current = node;\n    do {\n        var isScrollable = elementCouldBeScrolled(axis, current);\n        if (isScrollable) {\n            var _a = getScrollVariables(axis, current), s = _a[1], d = _a[2];\n            if (s > d) {\n                return true;\n            }\n        }\n        current = current.parentNode;\n    } while (current && current !== document.body);\n    return false;\n};\nvar getVScrollVariables = function (_a) {\n    var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;\n    return [scrollTop, scrollHeight, clientHeight];\n};\nvar getHScrollVariables = function (_a) {\n    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;\n    return [scrollLeft, scrollWidth, clientWidth];\n};\nvar elementCouldBeScrolled = function (axis, node) {\n    return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);\n};\nvar getScrollVariables = function (axis, node) {\n    return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);\n};\nexport var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {\n    var delta = sourceDelta;\n    // find scrollable target\n    var target = event.target;\n    var targetInLock = endTarget.contains(target);\n    var shouldCancelScroll = false;\n    var isDeltaPositive = delta > 0;\n    var availableScroll = 0;\n    var availableScrollTop = 0;\n    do {\n        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];\n        var elementScroll = scroll_1 - capacity - position;\n        if (position || elementScroll) {\n            if (elementCouldBeScrolled(axis, target)) {\n                availableScroll += elementScroll;\n                availableScrollTop += position;\n            }\n        }\n        target = target.parentNode;\n    } while (\n    // portaled content\n    (!targetInLock && target !== document.body) ||\n        // self content\n        (targetInLock && (endTarget.contains(target) || endTarget === target)));\n    if (isDeltaPositive &&\n        ((noOverscroll && availableScroll === 0) ||\n            (!noOverscroll && delta > availableScroll))) {\n        shouldCancelScroll = true;\n    }\n    else if (!isDeltaPositive &&\n        ((noOverscroll && availableScrollTop === 0) ||\n            (!noOverscroll && -delta > availableScrollTop))) {\n        shouldCancelScroll = true;\n    }\n    return shouldCancelScroll;\n};\n","var passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        var options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passiveSupported = true;\n                return true;\n            }\n        });\n        window.addEventListener('test', options, options);\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\nexport var nonPassive = passiveSupported ? { passive: false } : false;\n","import * as React from 'react';\nimport { RemoveScrollBar } from 'react-remove-scroll-bar';\nimport { styleSingleton } from 'react-style-singleton';\nimport { handleScroll, locationCouldBeScrolled } from './handleScroll';\nimport { nonPassive } from './aggresiveCapture';\nexport var getTouchXY = function (event) {\n    return 'changedTouches' in event\n        ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY]\n        : [0, 0];\n};\nexport var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };\nvar extractRef = function (ref) {\n    return ref && 'current' in ref ? ref.current : ref;\n};\nvar deltaCompare = function (x, y) {\n    return x[0] === y[0] && x[1] === y[1];\n};\nvar generateStyle = function (id) { return \"\\n  .block-interactivity-\" + id + \" {pointer-events: none;}\\n  .allow-interactivity-\" + id + \" {pointer-events: all;}\\n\"; };\nvar idCounter = 0;\nvar lockStack = [];\nexport function RemoveScrollSideCar(props) {\n    var shouldPreventQueue = React.useRef([]);\n    var touchStartRef = React.useRef([0, 0]);\n    var activeAxis = React.useRef();\n    var id = React.useState(idCounter++)[0];\n    var Style = React.useState(function () { return styleSingleton(); })[0];\n    var lastProps = React.useRef(props);\n    React.useEffect(function () {\n        lastProps.current = props;\n    }, [props]);\n    React.useEffect(function () {\n        if (props.inert) {\n            document.body.classList.add(\"block-interactivity-\" + id);\n            var allow_1 = [\n                props.lockRef.current\n            ].concat((props.shards || []).map(extractRef)).filter(Boolean);\n            allow_1.forEach(function (el) { return el.classList.add(\"allow-interactivity-\" + id); });\n            return function () {\n                document.body.classList.remove(\"block-interactivity-\" + id);\n                allow_1.forEach(function (el) {\n                    return el.classList.remove(\"allow-interactivity-\" + id);\n                });\n            };\n        }\n        return;\n    }, [props.inert, props.lockRef.current, props.shards]);\n    var shouldCancelEvent = React.useCallback(function (event, parent) {\n        if ('touches' in event && event.touches.length === 2) {\n            return !lastProps.current.allowPinchZoom;\n        }\n        var touch = getTouchXY(event);\n        var touchStart = touchStartRef.current;\n        var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];\n        var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];\n        var currentAxis;\n        var target = event.target;\n        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';\n        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n        if (!canBeScrolledInMainDirection) {\n            return true;\n        }\n        if (canBeScrolledInMainDirection) {\n            currentAxis = moveDirection;\n        }\n        else {\n            currentAxis = moveDirection === 'v' ? 'h' : 'v';\n            canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n            // other axis might be not scrollable\n        }\n        if (!canBeScrolledInMainDirection) {\n            return false;\n        }\n        if (!activeAxis.current &&\n            'changedTouches' in event &&\n            (deltaX || deltaY)) {\n            activeAxis.current = currentAxis;\n        }\n        if (!currentAxis) {\n            return true;\n        }\n        var cancelingAxis = activeAxis.current || currentAxis;\n        return handleScroll(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY, true);\n    }, []);\n    var shouldPrevent = React.useCallback(function (_event) {\n        var event = _event;\n        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {\n            // not the last active\n            return;\n        }\n        var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);\n        var sourceEvent = shouldPreventQueue.current.filter(function (e) {\n            return e.name === event.type &&\n                e.target === event.target &&\n                deltaCompare(e.delta, delta);\n        })[0];\n        // self event, and should be canceled\n        if (sourceEvent && sourceEvent.should) {\n            event.preventDefault();\n            return;\n        }\n        // outside or shard event\n        if (!sourceEvent) {\n            var shardNodes = (lastProps.current.shards || [])\n                .map(extractRef)\n                .filter(Boolean)\n                .filter(function (node) { return node.contains(event.target); });\n            var shouldStop = shardNodes.length > 0\n                ? shouldCancelEvent(event, shardNodes[0])\n                : !lastProps.current.noIsolation;\n            if (shouldStop) {\n                event.preventDefault();\n            }\n        }\n    }, []);\n    var shouldCancel = React.useCallback(function (name, delta, target, should) {\n        var event = { name: name, delta: delta, target: target, should: should };\n        shouldPreventQueue.current.push(event);\n        setTimeout(function () {\n            shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) { return e !== event; });\n        }, 1);\n    }, []);\n    var scrollTouchStart = React.useCallback(function (event) {\n        touchStartRef.current = getTouchXY(event);\n        activeAxis.current = undefined;\n    }, []);\n    var scrollWheel = React.useCallback(function (event) {\n        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    var scrollTouchMove = React.useCallback(function (event) {\n        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    React.useEffect(function () {\n        lockStack.push(Style);\n        props.setCallbacks({\n            onScrollCapture: scrollWheel,\n            onWheelCapture: scrollWheel,\n            onTouchMoveCapture: scrollTouchMove\n        });\n        document.addEventListener('wheel', shouldPrevent, nonPassive);\n        document.addEventListener('touchmove', shouldPrevent, nonPassive);\n        document.addEventListener('touchstart', scrollTouchStart, nonPassive);\n        return function () {\n            lockStack = lockStack.filter(function (inst) { return inst !== Style; });\n            document.removeEventListener('wheel', shouldPrevent, nonPassive);\n            document.removeEventListener('touchmove', shouldPrevent, nonPassive);\n            document.removeEventListener('touchstart', scrollTouchStart, nonPassive);\n        };\n    }, []);\n    var removeScrollBar = props.removeScrollBar, inert = props.inert;\n    return (React.createElement(React.Fragment, null,\n        inert ? React.createElement(Style, { styles: generateStyle(id) }) : null,\n        removeScrollBar ? React.createElement(RemoveScrollBar, { gapMode: \"margin\" }) : null));\n}\n","import { exportSidecar } from 'use-sidecar';\nimport { RemoveScrollSideCar } from './SideEffect';\nimport { effectCar } from './medium';\nexport default exportSidecar(effectCar, RemoveScrollSideCar);\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScroll } from './UI';\nimport SideCar from './sidecar';\nvar ReactRemoveScroll = React.forwardRef(function (props, ref) { return (React.createElement(RemoveScroll, tslib_1.__assign({}, props, { ref: ref, sideCar: SideCar }))); });\nReactRemoveScroll.classNames = RemoveScroll.classNames;\nexport default ReactRemoveScroll;\n","import { useCallbackRef } from './useRef';\nimport { assignRef } from './assignRef';\n/**\n * Merges two or more refs together providing a single interface to set their value\n * @param {RefObject|Ref} refs\n * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}\n *\n * @see {@link mergeRefs} a version without buit-in memoization\n * @see https://github.com/theKashey/use-callback-ref#usemergerefs\n * @example\n * const Component = React.forwardRef((props, ref) => {\n *   const ownRef = useRef();\n *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together\n *   return <div ref={domRef}>...</div>\n * }\n */\nexport function useMergeRefs(refs, defaultValue) {\n    return useCallbackRef(defaultValue, function (newValue) {\n        return refs.forEach(function (ref) { return assignRef(ref, newValue); });\n    });\n}\n","import { useState } from 'react';\n/**\n * creates a MutableRef with ref change callback\n * @param initialValue - initial ref value\n * @param {Function} callback - a callback to run when value changes\n *\n * @example\n * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);\n * ref.current = 1;\n * // prints 0 -> 1\n *\n * @see https://reactjs.org/docs/hooks-reference.html#useref\n * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref\n * @returns {MutableRefObject}\n */\nexport function useCallbackRef(initialValue, callback) {\n    var ref = useState(function () { return ({\n        // value\n        value: initialValue,\n        // last callback\n        callback: callback,\n        // \"memoized\" public interface\n        facade: {\n            get current() {\n                return ref.value;\n            },\n            set current(value) {\n                var last = ref.value;\n                if (last !== value) {\n                    ref.value = value;\n                    ref.callback(value, last);\n                }\n            }\n        }\n    }); })[0];\n    // update callback\n    ref.callback = callback;\n    return ref.facade;\n}\n","/**\n * Assigns a value for a given ref, no matter of the ref format\n * @param {RefObject} ref - a callback function or ref object\n * @param value - a new value\n *\n * @see https://github.com/theKashey/use-callback-ref#assignref\n * @example\n * const refObject = useRef();\n * const refFn = (ref) => {....}\n *\n * assignRef(refObject, \"refValue\");\n * assignRef(refFn, \"refValue\");\n */\nexport function assignRef(ref, value) {\n    if (typeof ref === 'function') {\n        ref(value);\n    }\n    else if (ref) {\n        ref.current = value;\n    }\n    return ref;\n}\n"],"sourceRoot":""}