@cleartrip/ct-design-focus-lock 1.1.0

package/dist/ct-design-focus-lock.umd.js

@@ -0,0 +1,1688 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react/jsx-runtime'), require('react')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'react/jsx-runtime', 'react'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CTDesignSystemFocusLock = {}, global.jsxRuntime, global.React));
+})(this, (function (exports, jsxRuntime, React$1) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var React__namespace = /*#__PURE__*/_interopNamespace(React$1);
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol */
+
+    var __assign = function () {
+      __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    function _objectWithoutPropertiesLoose(source, excluded) {
+      if (source == null) return {};
+      var target = {};
+      var sourceKeys = Object.keys(source);
+      var key, i;
+      for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+      }
+      return target;
+    }
+
+    function _extends() {
+      _extends = Object.assign ? Object.assign.bind() : function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+
+    /**
+     * Copyright (c) 2013-present, Facebook, Inc.
+     *
+     * This source code is licensed under the MIT license found in the
+     * LICENSE file in the root directory of this source tree.
+     */
+    var ReactPropTypesSecret_1;
+    var hasRequiredReactPropTypesSecret;
+    function requireReactPropTypesSecret() {
+      if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
+      hasRequiredReactPropTypesSecret = 1;
+      var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+      ReactPropTypesSecret_1 = ReactPropTypesSecret;
+      return ReactPropTypesSecret_1;
+    }
+
+    /**
+     * Copyright (c) 2013-present, Facebook, Inc.
+     *
+     * This source code is licensed under the MIT license found in the
+     * LICENSE file in the root directory of this source tree.
+     */
+    var factoryWithThrowingShims;
+    var hasRequiredFactoryWithThrowingShims;
+    function requireFactoryWithThrowingShims() {
+      if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+      hasRequiredFactoryWithThrowingShims = 1;
+      var ReactPropTypesSecret = requireReactPropTypesSecret();
+      function emptyFunction() {}
+      function emptyFunctionWithReset() {}
+      emptyFunctionWithReset.resetWarningCache = emptyFunction;
+      factoryWithThrowingShims = function () {
+        function shim(props, propName, componentName, location, propFullName, secret) {
+          if (secret === ReactPropTypesSecret) {
+            // It is still safe when called from React.
+            return;
+          }
+          var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+          err.name = 'Invariant Violation';
+          throw err;
+        }
+        shim.isRequired = shim;
+        function getShim() {
+          return shim;
+        }
+        // Important!
+        // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+        var ReactPropTypes = {
+          array: shim,
+          bigint: shim,
+          bool: shim,
+          func: shim,
+          number: shim,
+          object: shim,
+          string: shim,
+          symbol: shim,
+          any: shim,
+          arrayOf: getShim,
+          element: shim,
+          elementType: shim,
+          instanceOf: getShim,
+          node: shim,
+          objectOf: getShim,
+          oneOf: getShim,
+          oneOfType: getShim,
+          shape: getShim,
+          exact: getShim,
+          checkPropTypes: emptyFunctionWithReset,
+          resetWarningCache: emptyFunction
+        };
+        ReactPropTypes.PropTypes = ReactPropTypes;
+        return ReactPropTypes;
+      };
+      return factoryWithThrowingShims;
+    }
+
+    /**
+     * Copyright (c) 2013-present, Facebook, Inc.
+     *
+     * This source code is licensed under the MIT license found in the
+     * LICENSE file in the root directory of this source tree.
+     */
+    {
+      // By explicitly using `prop-types` you are opting into new production behavior.
+      // http://fb.me/prop-types-in-prod
+      requireFactoryWithThrowingShims()();
+    }
+
+    /**
+     * defines a focus group
+     */
+    var FOCUS_GROUP = 'data-focus-lock';
+    /**
+     * disables element discovery inside a group marked by key
+     */
+    var FOCUS_DISABLED = 'data-focus-lock-disabled';
+    /**
+     * allows uncontrolled focus within the marked area, effectively disabling focus lock for it's content
+     */
+    var FOCUS_ALLOW = 'data-no-focus-lock';
+    /**
+     * instructs autofocus engine to pick default autofocus inside a given node
+     * can be set on the element or container
+     */
+    var FOCUS_AUTO = 'data-autofocus-inside';
+    /**
+     * instructs autofocus to ignore elements within a given node
+     * can be set on the element or container
+     */
+    var FOCUS_NO_AUTOFOCUS = 'data-no-autofocus';
+
+    /**
+     * Assigns a value for a given ref, no matter of the ref format
+     * @param {RefObject} ref - a callback function or ref object
+     * @param value - a new value
+     *
+     * @see https://github.com/theKashey/use-callback-ref#assignref
+     * @example
+     * const refObject = useRef();
+     * const refFn = (ref) => {....}
+     *
+     * assignRef(refObject, "refValue");
+     * assignRef(refFn, "refValue");
+     */
+    function assignRef(ref, value) {
+      if (typeof ref === 'function') {
+        ref(value);
+      } else if (ref) {
+        ref.current = value;
+      }
+      return ref;
+    }
+
+    /**
+     * creates a MutableRef with ref change callback
+     * @param initialValue - initial ref value
+     * @param {Function} callback - a callback to run when value changes
+     *
+     * @example
+     * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);
+     * ref.current = 1;
+     * // prints 0 -> 1
+     *
+     * @see https://reactjs.org/docs/hooks-reference.html#useref
+     * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref
+     * @returns {MutableRefObject}
+     */
+    function useCallbackRef(initialValue, callback) {
+      var ref = React$1.useState(function () {
+        return {
+          // value
+          value: initialValue,
+          // last callback
+          callback: callback,
+          // "memoized" public interface
+          facade: {
+            get current() {
+              return ref.value;
+            },
+            set current(value) {
+              var last = ref.value;
+              if (last !== value) {
+                ref.value = value;
+                ref.callback(value, last);
+              }
+            }
+          }
+        };
+      })[0];
+      // update callback
+      ref.callback = callback;
+      return ref.facade;
+    }
+
+    /**
+     * Merges two or more refs together providing a single interface to set their value
+     * @param {RefObject|Ref} refs
+     * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
+     *
+     * @see {@link mergeRefs} a version without buit-in memoization
+     * @see https://github.com/theKashey/use-callback-ref#usemergerefs
+     * @example
+     * const Component = React.forwardRef((props, ref) => {
+     *   const ownRef = useRef();
+     *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together
+     *   return <div ref={domRef}>...</div>
+     * }
+     */
+    function useMergeRefs(refs, defaultValue) {
+      return useCallbackRef(defaultValue || null, function (newValue) {
+        return refs.forEach(function (ref) {
+          return assignRef(ref, newValue);
+        });
+      });
+    }
+
+    var hiddenGuard = {
+      width: '1px',
+      height: '0px',
+      padding: 0,
+      overflow: 'hidden',
+      position: 'fixed',
+      top: '1px',
+      left: '1px'
+    };
+
+    function ItoI(a) {
+      return a;
+    }
+    function innerCreateMedium(defaults, middleware) {
+      if (middleware === void 0) {
+        middleware = ItoI;
+      }
+      var buffer = [];
+      var assigned = false;
+      var medium = {
+        read: function () {
+          if (assigned) {
+            throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');
+          }
+          if (buffer.length) {
+            return buffer[buffer.length - 1];
+          }
+          return defaults;
+        },
+        useMedium: function (data) {
+          var item = middleware(data, assigned);
+          buffer.push(item);
+          return function () {
+            buffer = buffer.filter(function (x) {
+              return x !== item;
+            });
+          };
+        },
+        assignSyncMedium: function (cb) {
+          assigned = true;
+          while (buffer.length) {
+            var cbs = buffer;
+            buffer = [];
+            cbs.forEach(cb);
+          }
+          buffer = {
+            push: function (x) {
+              return cb(x);
+            },
+            filter: function () {
+              return buffer;
+            }
+          };
+        },
+        assignMedium: function (cb) {
+          assigned = true;
+          var pendingQueue = [];
+          if (buffer.length) {
+            var cbs = buffer;
+            buffer = [];
+            cbs.forEach(cb);
+            pendingQueue = buffer;
+          }
+          var executeQueue = function () {
+            var cbs = pendingQueue;
+            pendingQueue = [];
+            cbs.forEach(cb);
+          };
+          var cycle = function () {
+            return Promise.resolve().then(executeQueue);
+          };
+          cycle();
+          buffer = {
+            push: function (x) {
+              pendingQueue.push(x);
+              cycle();
+            },
+            filter: function (filter) {
+              pendingQueue = pendingQueue.filter(filter);
+              return buffer;
+            }
+          };
+        }
+      };
+      return medium;
+    }
+    function createMedium(defaults, middleware) {
+      if (middleware === void 0) {
+        middleware = ItoI;
+      }
+      return innerCreateMedium(defaults, middleware);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    function createSidecarMedium(options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var medium = innerCreateMedium(null);
+      medium.options = __assign({
+        async: true,
+        ssr: false
+      }, options);
+      return medium;
+    }
+
+    var mediumFocus = createMedium({}, function (_ref) {
+      var target = _ref.target,
+        currentTarget = _ref.currentTarget;
+      return {
+        target: target,
+        currentTarget: currentTarget
+      };
+    });
+    var mediumBlur = createMedium();
+    var mediumEffect = createMedium();
+    var mediumSidecar = createSidecarMedium({
+      async: true // focus-lock sidecar is not required on the server
+      // however, it might be required for JSDOM tests
+      // ssr: true,
+    });
+
+    var emptyArray = [];
+    var FocusLock$1 = /*#__PURE__*/React__namespace.forwardRef(function FocusLockUI(props, parentRef) {
+      var _extends2;
+      var _React$useState = React__namespace.useState(),
+        realObserved = _React$useState[0],
+        setObserved = _React$useState[1];
+      var observed = React__namespace.useRef();
+      var isActive = React__namespace.useRef(false);
+      var originalFocusedElement = React__namespace.useRef(null);
+      var children = props.children,
+        disabled = props.disabled,
+        noFocusGuards = props.noFocusGuards,
+        persistentFocus = props.persistentFocus,
+        crossFrame = props.crossFrame,
+        autoFocus = props.autoFocus;
+        props.allowTextSelection;
+        var group = props.group,
+        className = props.className,
+        whiteList = props.whiteList,
+        hasPositiveIndices = props.hasPositiveIndices,
+        _props$shards = props.shards,
+        shards = _props$shards === void 0 ? emptyArray : _props$shards,
+        _props$as = props.as,
+        Container = _props$as === void 0 ? 'div' : _props$as,
+        _props$lockProps = props.lockProps,
+        containerProps = _props$lockProps === void 0 ? {} : _props$lockProps,
+        SideCar = props.sideCar,
+        shouldReturnFocus = props.returnFocus,
+        focusOptions = props.focusOptions,
+        onActivationCallback = props.onActivation,
+        onDeactivationCallback = props.onDeactivation;
+      var _React$useState2 = React__namespace.useState({}),
+        id = _React$useState2[0]; // SIDE EFFECT CALLBACKS
+
+      var onActivation = React__namespace.useCallback(function () {
+        originalFocusedElement.current = originalFocusedElement.current || document && document.activeElement;
+        if (observed.current && onActivationCallback) {
+          onActivationCallback(observed.current);
+        }
+        isActive.current = true;
+      }, [onActivationCallback]);
+      var onDeactivation = React__namespace.useCallback(function () {
+        isActive.current = false;
+        if (onDeactivationCallback) {
+          onDeactivationCallback(observed.current);
+        }
+      }, [onDeactivationCallback]);
+      React$1.useEffect(function () {
+        if (!disabled) {
+          // cleanup return focus on trap deactivation
+          // sideEffect/returnFocus should happen by this time
+          originalFocusedElement.current = null;
+        }
+      }, []);
+      var returnFocus = React__namespace.useCallback(function (allowDefer) {
+        var returnFocusTo = originalFocusedElement.current;
+        if (returnFocusTo && returnFocusTo.focus) {
+          var howToReturnFocus = typeof shouldReturnFocus === 'function' ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;
+          if (howToReturnFocus) {
+            var returnFocusOptions = typeof howToReturnFocus === 'object' ? howToReturnFocus : undefined;
+            originalFocusedElement.current = null;
+            if (allowDefer) {
+              // React might return focus after update
+              // it's safer to defer the action
+              Promise.resolve().then(function () {
+                return returnFocusTo.focus(returnFocusOptions);
+              });
+            } else {
+              returnFocusTo.focus(returnFocusOptions);
+            }
+          }
+        }
+      }, [shouldReturnFocus]); // MEDIUM CALLBACKS
+
+      var onFocus = React__namespace.useCallback(function (event) {
+        if (isActive.current) {
+          mediumFocus.useMedium(event);
+        }
+      }, []);
+      var onBlur = mediumBlur.useMedium; // REF PROPAGATION
+      // not using real refs due to race conditions
+
+      var setObserveNode = React__namespace.useCallback(function (newObserved) {
+        if (observed.current !== newObserved) {
+          observed.current = newObserved;
+          setObserved(newObserved);
+        }
+      }, []);
+      var lockProps = _extends((_extends2 = {}, _extends2[FOCUS_DISABLED] = disabled && 'disabled', _extends2[FOCUS_GROUP] = group, _extends2), containerProps);
+      var hasLeadingGuards = noFocusGuards !== true;
+      var hasTailingGuards = hasLeadingGuards && noFocusGuards !== 'tail';
+      var mergedRef = useMergeRefs([parentRef, setObserveNode]);
+      return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, hasLeadingGuards && [/*#__PURE__*/
+      // nearest focus guard
+      React__namespace.createElement("div", {
+        key: "guard-first",
+        "data-focus-guard": true,
+        tabIndex: disabled ? -1 : 0,
+        style: hiddenGuard
+      }),
+      // first tabbed element guard
+      hasPositiveIndices ? /*#__PURE__*/React__namespace.createElement("div", {
+        key: "guard-nearest",
+        "data-focus-guard": true,
+        tabIndex: disabled ? -1 : 1,
+        style: hiddenGuard
+      }) : null], !disabled && /*#__PURE__*/React__namespace.createElement(SideCar, {
+        id: id,
+        sideCar: mediumSidecar,
+        observed: realObserved,
+        disabled: disabled,
+        persistentFocus: persistentFocus,
+        crossFrame: crossFrame,
+        autoFocus: autoFocus,
+        whiteList: whiteList,
+        shards: shards,
+        onActivation: onActivation,
+        onDeactivation: onDeactivation,
+        returnFocus: returnFocus,
+        focusOptions: focusOptions
+      }), /*#__PURE__*/React__namespace.createElement(Container, _extends({
+        ref: mergedRef
+      }, lockProps, {
+        className: className,
+        onBlur: onBlur,
+        onFocus: onFocus
+      }), children), hasTailingGuards && /*#__PURE__*/React__namespace.createElement("div", {
+        "data-focus-guard": true,
+        tabIndex: disabled ? -1 : 0,
+        style: hiddenGuard
+      }));
+    });
+    FocusLock$1.propTypes = {};
+    FocusLock$1.defaultProps = {
+      children: undefined,
+      disabled: false,
+      returnFocus: false,
+      focusOptions: undefined,
+      noFocusGuards: false,
+      autoFocus: true,
+      persistentFocus: false,
+      crossFrame: true,
+      hasPositiveIndices: undefined,
+      allowTextSelection: undefined,
+      group: undefined,
+      className: undefined,
+      whiteList: undefined,
+      shards: undefined,
+      as: 'div',
+      lockProps: {},
+      onActivation: undefined,
+      onDeactivation: undefined
+    };
+
+    var inheritsLooseExports = {};
+    var inheritsLoose = {
+      get exports(){ return inheritsLooseExports; },
+      set exports(v){ inheritsLooseExports = v; },
+    };
+
+    var setPrototypeOfExports = {};
+    var setPrototypeOf = {
+      get exports(){ return setPrototypeOfExports; },
+      set exports(v){ setPrototypeOfExports = v; },
+    };
+
+    (function (module) {
+      function _setPrototypeOf(o, p) {
+        module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+          o.__proto__ = p;
+          return o;
+        }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+        return _setPrototypeOf(o, p);
+      }
+      module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(setPrototypeOf);
+
+    (function (module) {
+      var setPrototypeOf = setPrototypeOfExports;
+      function _inheritsLoose(subClass, superClass) {
+        subClass.prototype = Object.create(superClass.prototype);
+        subClass.prototype.constructor = subClass;
+        setPrototypeOf(subClass, superClass);
+      }
+      module.exports = _inheritsLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(inheritsLoose);
+
+    var definePropertyExports = {};
+    var defineProperty = {
+      get exports(){ return definePropertyExports; },
+      set exports(v){ definePropertyExports = v; },
+    };
+
+    var toPropertyKeyExports = {};
+    var toPropertyKey = {
+      get exports(){ return toPropertyKeyExports; },
+      set exports(v){ toPropertyKeyExports = v; },
+    };
+
+    var _typeofExports = {};
+    var _typeof = {
+      get exports(){ return _typeofExports; },
+      set exports(v){ _typeofExports = v; },
+    };
+
+    (function (module) {
+      function _typeof(o) {
+        "@babel/helpers - typeof";
+
+        return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+          return typeof o;
+        } : function (o) {
+          return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+        }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(o);
+      }
+      module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(_typeof);
+
+    var toPrimitiveExports = {};
+    var toPrimitive = {
+      get exports(){ return toPrimitiveExports; },
+      set exports(v){ toPrimitiveExports = v; },
+    };
+
+    (function (module) {
+      var _typeof = _typeofExports["default"];
+      function _toPrimitive(input, hint) {
+        if (_typeof(input) !== "object" || input === null) return input;
+        var prim = input[Symbol.toPrimitive];
+        if (prim !== undefined) {
+          var res = prim.call(input, hint || "default");
+          if (_typeof(res) !== "object") return res;
+          throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+        return (hint === "string" ? String : Number)(input);
+      }
+      module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(toPrimitive);
+
+    (function (module) {
+      var _typeof = _typeofExports["default"];
+      var toPrimitive = toPrimitiveExports;
+      function _toPropertyKey(arg) {
+        var key = toPrimitive(arg, "string");
+        return _typeof(key) === "symbol" ? key : String(key);
+      }
+      module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(toPropertyKey);
+
+    (function (module) {
+      var toPropertyKey = toPropertyKeyExports;
+      function _defineProperty(obj, key, value) {
+        key = toPropertyKey(key);
+        if (key in obj) {
+          Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+        } else {
+          obj[key] = value;
+        }
+        return obj;
+      }
+      module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(defineProperty);
+
+    function _interopDefault$1(ex) {
+      return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;
+    }
+    var _inheritsLoose = _interopDefault$1(inheritsLooseExports);
+    var _defineProperty = _interopDefault$1(definePropertyExports);
+    var React = React__namespace.default;
+    var React__default = _interopDefault$1(React);
+    function withSideEffect(reducePropsToState, handleStateChangeOnClient) {
+      function getDisplayName(WrappedComponent) {
+        return WrappedComponent.displayName || WrappedComponent.name || 'Component';
+      }
+      return function wrap(WrappedComponent) {
+        var mountedInstances = [];
+        var state;
+        function emitChange() {
+          state = reducePropsToState(mountedInstances.map(function (instance) {
+            return instance.props;
+          }));
+          handleStateChangeOnClient(state);
+        }
+        var SideEffect = /*#__PURE__*/function (_PureComponent) {
+          _inheritsLoose(SideEffect, _PureComponent);
+          function SideEffect() {
+            return _PureComponent.apply(this, arguments) || this;
+          }
+
+          // Try to use displayName of wrapped component
+          SideEffect.peek = function peek() {
+            return state;
+          };
+          var _proto = SideEffect.prototype;
+          _proto.componentDidMount = function componentDidMount() {
+            mountedInstances.push(this);
+            emitChange();
+          };
+          _proto.componentDidUpdate = function componentDidUpdate() {
+            emitChange();
+          };
+          _proto.componentWillUnmount = function componentWillUnmount() {
+            var index = mountedInstances.indexOf(this);
+            mountedInstances.splice(index, 1);
+            emitChange();
+          };
+          _proto.render = function render() {
+            return /*#__PURE__*/React__default.createElement(WrappedComponent, this.props);
+          };
+          return SideEffect;
+        }(React.PureComponent);
+        _defineProperty(SideEffect, "displayName", "SideEffect(" + getDisplayName(WrappedComponent) + ")");
+        return SideEffect;
+      };
+    }
+    var lib = withSideEffect;
+
+    /*
+    IE11 support
+     */
+    var toArray = function (a) {
+      var ret = Array(a.length);
+      for (var i = 0; i < a.length; ++i) {
+        ret[i] = a[i];
+      }
+      return ret;
+    };
+    var asArray = function (a) {
+      return Array.isArray(a) ? a : [a];
+    };
+    var getFirst = function (a) {
+      return Array.isArray(a) ? a[0] : a;
+    };
+
+    var isElementHidden = function (node) {
+      // we can measure only "elements"
+      // consider others as "visible"
+      if (node.nodeType !== Node.ELEMENT_NODE) {
+        return false;
+      }
+      var computedStyle = window.getComputedStyle(node, null);
+      if (!computedStyle || !computedStyle.getPropertyValue) {
+        return false;
+      }
+      return computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden';
+    };
+    var getParentNode = function (node) {
+      // DOCUMENT_FRAGMENT_NODE can also point on ShadowRoot. In this case .host will point on the next node
+      return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE ?
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      node.parentNode.host : node.parentNode;
+    };
+    var isTopNode = function (node) {
+      // @ts-ignore
+      return node === document || node && node.nodeType === Node.DOCUMENT_NODE;
+    };
+    var isVisibleUncached = function (node, checkParent) {
+      return !node || isTopNode(node) || !isElementHidden(node) && checkParent(getParentNode(node));
+    };
+    var isVisibleCached = function (visibilityCache, node) {
+      var cached = visibilityCache.get(node);
+      if (cached !== undefined) {
+        return cached;
+      }
+      var result = isVisibleUncached(node, isVisibleCached.bind(undefined, visibilityCache));
+      visibilityCache.set(node, result);
+      return result;
+    };
+    var isAutoFocusAllowedUncached = function (node, checkParent) {
+      return node && !isTopNode(node) ? isAutoFocusAllowed(node) ? checkParent(getParentNode(node)) : false : true;
+    };
+    var isAutoFocusAllowedCached = function (cache, node) {
+      var cached = cache.get(node);
+      if (cached !== undefined) {
+        return cached;
+      }
+      var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(undefined, cache));
+      cache.set(node, result);
+      return result;
+    };
+    var getDataset = function (node) {
+      // @ts-ignore
+      return node.dataset;
+    };
+    var isHTMLButtonElement = function (node) {
+      return node.tagName === 'BUTTON';
+    };
+    var isHTMLInputElement = function (node) {
+      return node.tagName === 'INPUT';
+    };
+    var isRadioElement = function (node) {
+      return isHTMLInputElement(node) && node.type === 'radio';
+    };
+    var notHiddenInput = function (node) {
+      return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && (node.type === 'hidden' || node.disabled));
+    };
+    var isAutoFocusAllowed = function (node) {
+      var attribute = node.getAttribute(FOCUS_NO_AUTOFOCUS);
+      return ![true, 'true', ''].includes(attribute);
+    };
+    var isGuard = function (node) {
+      var _a;
+      return Boolean(node && ((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.focusGuard));
+    };
+    var isNotAGuard = function (node) {
+      return !isGuard(node);
+    };
+    var isDefined = function (x) {
+      return Boolean(x);
+    };
+
+    var tabSort = function (a, b) {
+      var tabDiff = a.tabIndex - b.tabIndex;
+      var indexDiff = a.index - b.index;
+      if (tabDiff) {
+        if (!a.tabIndex) {
+          return 1;
+        }
+        if (!b.tabIndex) {
+          return -1;
+        }
+      }
+      return tabDiff || indexDiff;
+    };
+    var orderByTabIndex = function (nodes, filterNegative, keepGuards) {
+      return toArray(nodes).map(function (node, index) {
+        return {
+          node: node,
+          index: index,
+          tabIndex: keepGuards && node.tabIndex === -1 ? (node.dataset || {}).focusGuard ? 0 : -1 : node.tabIndex
+        };
+      }).filter(function (data) {
+        return !filterNegative || data.tabIndex >= 0;
+      }).sort(tabSort);
+    };
+
+    /**
+     * list of the object to be considered as focusable
+     */
+    var tabbables = ['button:enabled', 'select:enabled', 'textarea:enabled', 'input:enabled',
+    // elements with explicit roles will also use explicit tabindex
+    // '[role="button"]',
+    'a[href]', 'area[href]', 'summary', 'iframe', 'object', 'embed', 'audio[controls]', 'video[controls]', '[tabindex]', '[contenteditable]', '[autofocus]'];
+
+    var queryTabbables = tabbables.join(',');
+    var queryGuardTabbables = "".concat(queryTabbables, ", [data-focus-guard]");
+    var getFocusablesWithShadowDom = function (parent, withGuards) {
+      return toArray((parent.shadowRoot || parent).children).reduce(function (acc, child) {
+        return acc.concat(child.matches(withGuards ? queryGuardTabbables : queryTabbables) ? [child] : [], getFocusablesWithShadowDom(child));
+      }, []);
+    };
+    var getFocusablesWithIFrame = function (parent, withGuards) {
+      var _a;
+      // contentDocument of iframe will be null if current origin cannot access it
+      if (parent instanceof HTMLIFrameElement && ((_a = parent.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) {
+        return getFocusables([parent.contentDocument.body], withGuards);
+      }
+      return [parent];
+    };
+    var getFocusables = function (parents, withGuards) {
+      return parents.reduce(function (acc, parent) {
+        var _a;
+        var focusableWithShadowDom = getFocusablesWithShadowDom(parent, withGuards);
+        var focusableWithIframes = (_a = []).concat.apply(_a, focusableWithShadowDom.map(function (node) {
+          return getFocusablesWithIFrame(node, withGuards);
+        }));
+        return acc.concat(
+        // add all tabbables inside and within shadow DOMs in DOM order
+        focusableWithIframes,
+        // add if node is tabbable itself
+        parent.parentNode ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function (node) {
+          return node === parent;
+        }) : []);
+      }, []);
+    };
+    /**
+     * return a list of focusable nodes within an area marked as "auto-focusable"
+     * @param parent
+     */
+    var getParentAutofocusables = function (parent) {
+      var parentFocus = parent.querySelectorAll("[".concat(FOCUS_AUTO, "]"));
+      return toArray(parentFocus).map(function (node) {
+        return getFocusables([node]);
+      }).reduce(function (acc, nodes) {
+        return acc.concat(nodes);
+      }, []);
+    };
+
+    /**
+     * given list of focusable elements keeps the ones user can interact with
+     * @param nodes
+     * @param visibilityCache
+     */
+    var filterFocusable = function (nodes, visibilityCache) {
+      return toArray(nodes).filter(function (node) {
+        return isVisibleCached(visibilityCache, node);
+      }).filter(function (node) {
+        return notHiddenInput(node);
+      });
+    };
+    var filterAutoFocusable = function (nodes, cache) {
+      if (cache === void 0) {
+        cache = new Map();
+      }
+      return toArray(nodes).filter(function (node) {
+        return isAutoFocusAllowedCached(cache, node);
+      });
+    };
+    /**
+     * !__WARNING__! Low level API.
+     * @returns all tabbable nodes
+     *
+     * @see {@link getFocusableNodes} to get any focusable element
+     *
+     * @param topNodes - array of top level HTMLElements to search inside
+     * @param visibilityCache - an cache to store intermediate measurements. Expected to be a fresh `new Map` on every call
+     */
+    var getTabbableNodes = function (topNodes, visibilityCache, withGuards) {
+      return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), true, withGuards);
+    };
+    /**
+     * !__WARNING__! Low level API.
+     *
+     * @returns anything "focusable", not only tabbable. The difference is in `tabIndex=-1`
+     * (without guards, as long as they are not expected to be ever focused)
+     *
+     * @see {@link getTabbableNodes} to get only tabble nodes element
+     *
+     * @param topNodes - array of top level HTMLElements to search inside
+     * @param visibilityCache - an cache to store intermediate measurements. Expected to be a fresh `new Map` on every call
+     */
+    var getFocusableNodes = function (topNodes, visibilityCache) {
+      return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), false);
+    };
+    /**
+     * return list of nodes which are expected to be auto-focused
+     * @param topNode
+     * @param visibilityCache
+     */
+    var parentAutofocusables = function (topNode, visibilityCache) {
+      return filterFocusable(getParentAutofocusables(topNode), visibilityCache);
+    };
+    /*
+     * Determines if element is contained in scope, including nested shadow DOMs
+     */
+    var contains = function (scope, element) {
+      if (scope.shadowRoot) {
+        return contains(scope.shadowRoot, element);
+      } else {
+        if (Object.getPrototypeOf(scope).contains !== undefined && Object.getPrototypeOf(scope).contains.call(scope, element)) {
+          return true;
+        }
+        return toArray(scope.children).some(function (child) {
+          var _a;
+          if (child instanceof HTMLIFrameElement) {
+            var iframeBody = (_a = child.contentDocument) === null || _a === void 0 ? void 0 : _a.body;
+            if (iframeBody) {
+              return contains(iframeBody, element);
+            }
+            return false;
+          }
+          return contains(child, element);
+        });
+      }
+    };
+
+    /**
+     * in case of multiple nodes nested inside each other
+     * keeps only top ones
+     * this is O(nlogn)
+     * @param nodes
+     * @returns {*}
+     */
+    var filterNested = function (nodes) {
+      var contained = new Set();
+      var l = nodes.length;
+      for (var i = 0; i < l; i += 1) {
+        for (var j = i + 1; j < l; j += 1) {
+          var position = nodes[i].compareDocumentPosition(nodes[j]);
+          /* eslint-disable no-bitwise */
+          if ((position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0) {
+            contained.add(j);
+          }
+          if ((position & Node.DOCUMENT_POSITION_CONTAINS) > 0) {
+            contained.add(i);
+          }
+          /* eslint-enable */
+        }
+      }
+
+      return nodes.filter(function (_, index) {
+        return !contained.has(index);
+      });
+    };
+    /**
+     * finds top most parent for a node
+     * @param node
+     * @returns {*}
+     */
+    var getTopParent = function (node) {
+      return node.parentNode ? getTopParent(node.parentNode) : node;
+    };
+    /**
+     * returns all "focus containers" inside a given node
+     * @param node - node or nodes to look inside
+     * @returns Element[]
+     */
+    var getAllAffectedNodes = function (node) {
+      var nodes = asArray(node);
+      return nodes.filter(Boolean).reduce(function (acc, currentNode) {
+        var group = currentNode.getAttribute(FOCUS_GROUP);
+        acc.push.apply(acc, group ? filterNested(toArray(getTopParent(currentNode).querySelectorAll("[".concat(FOCUS_GROUP, "=\"").concat(group, "\"]:not([").concat(FOCUS_DISABLED, "=\"disabled\"])")))) : [currentNode]);
+        return acc;
+      }, []);
+    };
+
+    var safeProbe = function (cb) {
+      try {
+        return cb();
+      } catch (e) {
+        return undefined;
+      }
+    };
+
+    /**
+     * returns active element from document or from nested shadowdoms
+     */
+    /**
+     * returns current active element. If the active element is a "container" itself(shadowRoot or iframe) returns active element inside it
+     * @param [inDocument]
+     */
+    var getActiveElement = function (inDocument) {
+      if (inDocument === void 0) {
+        inDocument = document;
+      }
+      if (!inDocument || !inDocument.activeElement) {
+        return undefined;
+      }
+      var activeElement = inDocument.activeElement;
+      return activeElement.shadowRoot ? getActiveElement(activeElement.shadowRoot) : activeElement instanceof HTMLIFrameElement && safeProbe(function () {
+        return activeElement.contentWindow.document;
+      }) ? getActiveElement(activeElement.contentWindow.document) : activeElement;
+    };
+
+    var focusInFrame = function (frame, activeElement) {
+      return frame === activeElement;
+    };
+    var focusInsideIframe = function (topNode, activeElement) {
+      return Boolean(toArray(topNode.querySelectorAll('iframe')).some(function (node) {
+        return focusInFrame(node, activeElement);
+      }));
+    };
+    /**
+     * @returns {Boolean} true, if the current focus is inside given node or nodes.
+     * Supports nodes hidden inside shadowDom
+     */
+    var focusInside = function (topNode, activeElement) {
+      // const activeElement = document && getActiveElement();
+      if (activeElement === void 0) {
+        activeElement = getActiveElement(getFirst(topNode).ownerDocument);
+      }
+      if (!activeElement || activeElement.dataset && activeElement.dataset.focusGuard) {
+        return false;
+      }
+      return getAllAffectedNodes(topNode).some(function (node) {
+        return contains(node, activeElement) || focusInsideIframe(node, activeElement);
+      });
+    };
+
+    /**
+     * checks if focus is hidden FROM the focus-lock
+     * ie contained inside a node focus-lock shall ignore
+     *
+     * This is a utility function coupled with {@link FOCUS_ALLOW} constant
+     *
+     * @returns {boolean} focus is currently is in "allow" area
+     */
+    var focusIsHidden = function (inDocument) {
+      if (inDocument === void 0) {
+        inDocument = document;
+      }
+      var activeElement = getActiveElement(inDocument);
+      if (!activeElement) {
+        return false;
+      }
+      // this does not support setting FOCUS_ALLOW within shadow dom
+      return toArray(inDocument.querySelectorAll("[".concat(FOCUS_ALLOW, "]"))).some(function (node) {
+        return contains(node, activeElement);
+      });
+    };
+
+    var findSelectedRadio = function (node, nodes) {
+      return nodes.filter(isRadioElement).filter(function (el) {
+        return el.name === node.name;
+      }).filter(function (el) {
+        return el.checked;
+      })[0] || node;
+    };
+    var correctNode = function (node, nodes) {
+      if (isRadioElement(node) && node.name) {
+        return findSelectedRadio(node, nodes);
+      }
+      return node;
+    };
+    /**
+     * giving a set of radio inputs keeps only selected (tabbable) ones
+     * @param nodes
+     */
+    var correctNodes = function (nodes) {
+      // IE11 has no Set(array) constructor
+      var resultSet = new Set();
+      nodes.forEach(function (node) {
+        return resultSet.add(correctNode(node, nodes));
+      });
+      // using filter to support IE11
+      return nodes.filter(function (node) {
+        return resultSet.has(node);
+      });
+    };
+
+    var pickFirstFocus = function (nodes) {
+      if (nodes[0] && nodes.length > 1) {
+        return correctNode(nodes[0], nodes);
+      }
+      return nodes[0];
+    };
+    var pickFocusable = function (nodes, index) {
+      if (nodes.length > 1) {
+        return nodes.indexOf(correctNode(nodes[index], nodes));
+      }
+      return index;
+    };
+
+    var NEW_FOCUS = 'NEW_FOCUS';
+    /**
+     * Main solver for the "find next focus" question
+     * @param innerNodes
+     * @param outerNodes
+     * @param activeElement
+     * @param lastNode
+     * @returns {number|string|undefined|*}
+     */
+    var newFocus = function (innerNodes, outerNodes, activeElement, lastNode) {
+      var cnt = innerNodes.length;
+      var firstFocus = innerNodes[0];
+      var lastFocus = innerNodes[cnt - 1];
+      var isOnGuard = isGuard(activeElement);
+      // focus is inside
+      if (activeElement && innerNodes.indexOf(activeElement) >= 0) {
+        return undefined;
+      }
+      var activeIndex = activeElement !== undefined ? outerNodes.indexOf(activeElement) : -1;
+      var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;
+      var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;
+      var indexDiff = activeIndex - lastIndex;
+      var firstNodeIndex = outerNodes.indexOf(firstFocus);
+      var lastNodeIndex = outerNodes.indexOf(lastFocus);
+      var correctedNodes = correctNodes(outerNodes);
+      var correctedIndex = activeElement !== undefined ? correctedNodes.indexOf(activeElement) : -1;
+      var correctedIndexDiff = correctedIndex - (lastNode ? correctedNodes.indexOf(lastNode) : activeIndex);
+      var returnFirstNode = pickFocusable(innerNodes, 0);
+      var returnLastNode = pickFocusable(innerNodes, cnt - 1);
+      // new focus
+      if (activeIndex === -1 || lastNodeInside === -1) {
+        return NEW_FOCUS;
+      }
+      // old focus
+      if (!indexDiff && lastNodeInside >= 0) {
+        return lastNodeInside;
+      }
+      // first element
+      if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {
+        return returnLastNode;
+      }
+      // last element
+      if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {
+        return returnFirstNode;
+      }
+      // jump out, but not on the guard
+      if (indexDiff && Math.abs(correctedIndexDiff) > 1) {
+        return lastNodeInside;
+      }
+      // focus above lock
+      if (activeIndex <= firstNodeIndex) {
+        return returnLastNode;
+      }
+      // focus below lock
+      if (activeIndex > lastNodeIndex) {
+        return returnFirstNode;
+      }
+      // index is inside tab order, but outside Lock
+      if (indexDiff) {
+        if (Math.abs(indexDiff) > 1) {
+          return lastNodeInside;
+        }
+        return (cnt + lastNodeInside + indexDiff) % cnt;
+      }
+      // do nothing
+      return undefined;
+    };
+
+    var findAutoFocused = function (autoFocusables) {
+      return function (node) {
+        var _a;
+        var autofocus = (_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.autofocus;
+        return (
+          // @ts-expect-error
+          node.autofocus ||
+          //
+          autofocus !== undefined && autofocus !== 'false' ||
+          //
+          autoFocusables.indexOf(node) >= 0
+        );
+      };
+    };
+    var pickAutofocus = function (nodesIndexes, orderedNodes, groups) {
+      var nodes = nodesIndexes.map(function (_a) {
+        var node = _a.node;
+        return node;
+      });
+      var autoFocusable = filterAutoFocusable(nodes.filter(findAutoFocused(groups)));
+      if (autoFocusable && autoFocusable.length) {
+        return pickFirstFocus(autoFocusable);
+      }
+      return pickFirstFocus(filterAutoFocusable(orderedNodes));
+    };
+
+    var getParents = function (node, parents) {
+      if (parents === void 0) {
+        parents = [];
+      }
+      parents.push(node);
+      if (node.parentNode) {
+        getParents(node.parentNode.host || node.parentNode, parents);
+      }
+      return parents;
+    };
+    /**
+     * finds a parent for both nodeA and nodeB
+     * @param nodeA
+     * @param nodeB
+     * @returns {boolean|*}
+     */
+    var getCommonParent = function (nodeA, nodeB) {
+      var parentsA = getParents(nodeA);
+      var parentsB = getParents(nodeB);
+      // tslint:disable-next-line:prefer-for-of
+      for (var i = 0; i < parentsA.length; i += 1) {
+        var currentParent = parentsA[i];
+        if (parentsB.indexOf(currentParent) >= 0) {
+          return currentParent;
+        }
+      }
+      return false;
+    };
+    var getTopCommonParent = function (baseActiveElement, leftEntry, rightEntries) {
+      var activeElements = asArray(baseActiveElement);
+      var leftEntries = asArray(leftEntry);
+      var activeElement = activeElements[0];
+      var topCommon = false;
+      leftEntries.filter(Boolean).forEach(function (entry) {
+        topCommon = getCommonParent(topCommon || entry, entry) || topCommon;
+        rightEntries.filter(Boolean).forEach(function (subEntry) {
+          var common = getCommonParent(activeElement, subEntry);
+          if (common) {
+            if (!topCommon || contains(common, topCommon)) {
+              topCommon = common;
+            } else {
+              topCommon = getCommonParent(common, topCommon);
+            }
+          }
+        });
+      });
+      // TODO: add assert here?
+      return topCommon;
+    };
+    /**
+     * return list of nodes which are expected to be autofocused inside a given top nodes
+     * @param entries
+     * @param visibilityCache
+     */
+    var allParentAutofocusables = function (entries, visibilityCache) {
+      return entries.reduce(function (acc, node) {
+        return acc.concat(parentAutofocusables(node, visibilityCache));
+      }, []);
+    };
+
+    var reorderNodes = function (srcNodes, dstNodes) {
+      var remap = new Map();
+      // no Set(dstNodes) for IE11 :(
+      dstNodes.forEach(function (entity) {
+        return remap.set(entity.node, entity);
+      });
+      // remap to dstNodes
+      return srcNodes.map(function (node) {
+        return remap.get(node);
+      }).filter(isDefined);
+    };
+    /**
+     * contains the main logic of the `focus-lock` package.
+     *
+     * ! you probably dont need this function !
+     *
+     * given top node(s) and the last active element returns the element to be focused next
+     * @returns element which should be focused to move focus inside
+     * @param topNode
+     * @param lastNode
+     */
+    var focusSolver = function (topNode, lastNode) {
+      var activeElement = getActiveElement(asArray(topNode).length > 0 ? document : getFirst(topNode).ownerDocument);
+      var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);
+      var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);
+      var visibilityCache = new Map();
+      var anyFocusable = getFocusableNodes(entries, visibilityCache);
+      var innerElements = getTabbableNodes(entries, visibilityCache).filter(function (_a) {
+        var node = _a.node;
+        return isNotAGuard(node);
+      });
+      if (!innerElements[0]) {
+        innerElements = anyFocusable;
+        if (!innerElements[0]) {
+          return undefined;
+        }
+      }
+      var outerNodes = getFocusableNodes([commonParent], visibilityCache).map(function (_a) {
+        var node = _a.node;
+        return node;
+      });
+      var orderedInnerElements = reorderNodes(outerNodes, innerElements);
+      var innerNodes = orderedInnerElements.map(function (_a) {
+        var node = _a.node;
+        return node;
+      });
+      var newId = newFocus(innerNodes, outerNodes, activeElement, lastNode);
+      if (newId === NEW_FOCUS) {
+        var focusNode = pickAutofocus(anyFocusable, innerNodes, allParentAutofocusables(entries, visibilityCache));
+        if (focusNode) {
+          return {
+            node: focusNode
+          };
+        } else {
+          console.warn('focus-lock: cannot find any node to move focus into');
+          return undefined;
+        }
+      }
+      if (newId === undefined) {
+        return newId;
+      }
+      return orderedInnerElements[newId];
+    };
+
+    /**
+     * @returns list of focusable elements inside a given top node
+     * @see {@link getFocusableNodes} for lower level access
+     */
+    var expandFocusableNodes = function (topNode) {
+      var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);
+      var commonParent = getTopCommonParent(topNode, topNode, entries);
+      var visibilityCache = new Map();
+      var outerNodes = getTabbableNodes([commonParent], visibilityCache, true);
+      var innerElements = getTabbableNodes(entries, visibilityCache).filter(function (_a) {
+        var node = _a.node;
+        return isNotAGuard(node);
+      }).map(function (_a) {
+        var node = _a.node;
+        return node;
+      });
+      return outerNodes.map(function (_a) {
+        var node = _a.node,
+          index = _a.index;
+        return {
+          node: node,
+          index: index,
+          lockItem: innerElements.indexOf(node) >= 0,
+          guard: isGuard(node)
+        };
+      });
+    };
+
+    var focusOn = function (target, focusOptions) {
+      if ('focus' in target) {
+        target.focus(focusOptions);
+      }
+      if ('contentWindow' in target && target.contentWindow) {
+        target.contentWindow.focus();
+      }
+    };
+
+    var guardCount = 0;
+    var lockDisabled = false;
+    /**
+     * The main functionality of the focus-lock package
+     *
+     * Contains focus at a given node.
+     * The last focused element will help to determine which element(first or last) should be focused.
+     * The found element will be focused.
+     *
+     * This is one time action (move), not a persistent focus-lock
+     *
+     * HTML markers (see {@link import('./constants').FOCUS_AUTO} constants) can control autofocus
+     * @see {@link focusSolver} for the same functionality without autofocus
+     */
+    var moveFocusInside = function (topNode, lastNode, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var focusable = focusSolver(topNode, lastNode);
+      // global local side effect to countain recursive lock activation and resolve focus-fighting
+      if (lockDisabled) {
+        return;
+      }
+      if (focusable) {
+        /** +FOCUS-FIGHTING prevention **/
+        if (guardCount > 2) {
+          // we have recursive entered back the lock activation
+          console.error('FocusLock: focus-fighting detected. Only one focus management system could be active. ' + 'See https://github.com/theKashey/focus-lock/#focus-fighting');
+          lockDisabled = true;
+          setTimeout(function () {
+            lockDisabled = false;
+          }, 1);
+          return;
+        }
+        guardCount++;
+        focusOn(focusable.node, options.focusOptions);
+        guardCount--;
+      }
+    };
+
+    function deferAction(action) {
+      setTimeout(action, 1);
+    }
+
+    /* eslint-disable no-mixed-operators */
+    var focusOnBody = function focusOnBody() {
+      return document && document.activeElement === document.body;
+    };
+    var isFreeFocus = function isFreeFocus() {
+      return focusOnBody() || focusIsHidden();
+    };
+    var lastActiveTrap = null;
+    var lastActiveFocus = null;
+    var lastPortaledElement = null;
+    var focusWasOutsideWindow = false;
+    var defaultWhitelist = function defaultWhitelist() {
+      return true;
+    };
+    var focusWhitelisted = function focusWhitelisted(activeElement) {
+      return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);
+    };
+    var recordPortal = function recordPortal(observerNode, portaledElement) {
+      lastPortaledElement = {
+        observerNode: observerNode,
+        portaledElement: portaledElement
+      };
+    };
+    var focusIsPortaledPair = function focusIsPortaledPair(element) {
+      return lastPortaledElement && lastPortaledElement.portaledElement === element;
+    };
+    function autoGuard(startIndex, end, step, allNodes) {
+      var lastGuard = null;
+      var i = startIndex;
+      do {
+        var item = allNodes[i];
+        if (item.guard) {
+          if (item.node.dataset.focusAutoGuard) {
+            lastGuard = item;
+          }
+        } else if (item.lockItem) {
+          if (i !== startIndex) {
+            // we will tab to the next element
+            return;
+          }
+          lastGuard = null;
+        } else {
+          break;
+        }
+      } while ((i += step) !== end);
+      if (lastGuard) {
+        lastGuard.node.tabIndex = 0;
+      }
+    }
+    var extractRef = function extractRef(ref) {
+      return ref && 'current' in ref ? ref.current : ref;
+    };
+    var focusWasOutside = function focusWasOutside(crossFrameOption) {
+      if (crossFrameOption) {
+        // with cross frame return true for any value
+        return Boolean(focusWasOutsideWindow);
+      } // in other case return only of focus went a while aho
+
+      return focusWasOutsideWindow === 'meanwhile';
+    };
+    var checkInHost = function checkInHost(check, el, boundary) {
+      return el && (
+      // find host equal to active element and check nested active element
+      el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) // dive up
+      || el.parentNode && checkInHost(check, el.parentNode, boundary));
+    };
+    var withinHost = function withinHost(activeElement, workingArea) {
+      return workingArea.some(function (area) {
+        return checkInHost(activeElement, area, area);
+      });
+    };
+    var activateTrap = function activateTrap() {
+      var result = false;
+      if (lastActiveTrap) {
+        var _lastActiveTrap = lastActiveTrap,
+          observed = _lastActiveTrap.observed,
+          persistentFocus = _lastActiveTrap.persistentFocus,
+          autoFocus = _lastActiveTrap.autoFocus,
+          shards = _lastActiveTrap.shards,
+          crossFrame = _lastActiveTrap.crossFrame,
+          focusOptions = _lastActiveTrap.focusOptions;
+        var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;
+        var activeElement = document && document.activeElement;
+        if (workingNode) {
+          var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));
+          if (!activeElement || focusWhitelisted(activeElement)) {
+            if (persistentFocus || focusWasOutside(crossFrame) || !isFreeFocus() || !lastActiveFocus && autoFocus) {
+              if (workingNode && !(
+              // active element is "inside" working area
+              focusInside(workingArea) ||
+              // check for shadow-dom contained elements
+              activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement))) {
+                if (document && !lastActiveFocus && activeElement && !autoFocus) {
+                  // Check if blur() exists, which is missing on certain elements on IE
+                  if (activeElement.blur) {
+                    activeElement.blur();
+                  }
+                  document.body.focus();
+                } else {
+                  result = moveFocusInside(workingArea, lastActiveFocus, {
+                    focusOptions: focusOptions
+                  });
+                  lastPortaledElement = {};
+                }
+              }
+              focusWasOutsideWindow = false;
+              lastActiveFocus = document && document.activeElement;
+            }
+          }
+          if (document) {
+            var newActiveElement = document && document.activeElement;
+            var allNodes = expandFocusableNodes(workingArea);
+            var focusedIndex = allNodes.map(function (_ref) {
+              var node = _ref.node;
+              return node;
+            }).indexOf(newActiveElement);
+            if (focusedIndex > -1) {
+              // remove old focus
+              allNodes.filter(function (_ref2) {
+                var guard = _ref2.guard,
+                  node = _ref2.node;
+                return guard && node.dataset.focusAutoGuard;
+              }).forEach(function (_ref3) {
+                var node = _ref3.node;
+                return node.removeAttribute('tabIndex');
+              });
+              autoGuard(focusedIndex, allNodes.length, +1, allNodes);
+              autoGuard(focusedIndex, -1, -1, allNodes);
+            }
+          }
+        }
+      }
+      return result;
+    };
+    var onTrap = function onTrap(event) {
+      if (activateTrap() && event) {
+        // prevent scroll jump
+        event.stopPropagation();
+        event.preventDefault();
+      }
+    };
+    var onBlur = function onBlur() {
+      return deferAction(activateTrap);
+    };
+    var onFocus = function onFocus(event) {
+      // detect portal
+      var source = event.target;
+      var currentNode = event.currentTarget;
+      if (!currentNode.contains(source)) {
+        recordPortal(currentNode, source);
+      }
+    };
+    var FocusWatcher = function FocusWatcher() {
+      return null;
+    };
+    var onWindowBlur = function onWindowBlur() {
+      focusWasOutsideWindow = 'just'; // using setTimeout to set  this variable after React/sidecar reaction
+
+      deferAction(function () {
+        focusWasOutsideWindow = 'meanwhile';
+      });
+    };
+    var attachHandler = function attachHandler() {
+      document.addEventListener('focusin', onTrap);
+      document.addEventListener('focusout', onBlur);
+      window.addEventListener('blur', onWindowBlur);
+    };
+    var detachHandler = function detachHandler() {
+      document.removeEventListener('focusin', onTrap);
+      document.removeEventListener('focusout', onBlur);
+      window.removeEventListener('blur', onWindowBlur);
+    };
+    function reducePropsToState(propsList) {
+      return propsList.filter(function (_ref5) {
+        var disabled = _ref5.disabled;
+        return !disabled;
+      });
+    }
+    function handleStateChangeOnClient(traps) {
+      var trap = traps.slice(-1)[0];
+      if (trap && !lastActiveTrap) {
+        attachHandler();
+      }
+      var lastTrap = lastActiveTrap;
+      var sameTrap = lastTrap && trap && trap.id === lastTrap.id;
+      lastActiveTrap = trap;
+      if (lastTrap && !sameTrap) {
+        lastTrap.onDeactivation(); // return focus only of last trap was removed
+
+        if (!traps.filter(function (_ref6) {
+          var id = _ref6.id;
+          return id === lastTrap.id;
+        }).length) {
+          // allow defer is no other trap is awaiting restore
+          lastTrap.returnFocus(!trap);
+        }
+      }
+      if (trap) {
+        lastActiveFocus = null;
+        if (!sameTrap || lastTrap.observed !== trap.observed) {
+          trap.onActivation();
+        }
+        activateTrap();
+        deferAction(activateTrap);
+      } else {
+        detachHandler();
+        lastActiveFocus = null;
+      }
+    } // bind medium
+
+    mediumFocus.assignSyncMedium(onFocus);
+    mediumBlur.assignMedium(onBlur);
+    mediumEffect.assignMedium(function (cb) {
+      return cb({
+        moveFocusInside: moveFocusInside,
+        focusInside: focusInside
+      });
+    });
+    var FocusTrap = lib(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);
+
+    /* that would be a BREAKING CHANGE!
+    // delaying sidecar execution till the first usage
+    const RequireSideCar = (props) => {
+      // eslint-disable-next-line global-require
+      const SideCar = require('./Trap').default;
+      return <SideCar {...props} />;
+    };
+    */
+
+    var FocusLockCombination = /*#__PURE__*/React__namespace.forwardRef(function FocusLockUICombination(props, ref) {
+      return /*#__PURE__*/React__namespace.createElement(FocusLock$1, _extends({
+        sideCar: FocusTrap,
+        ref: ref
+      }, props));
+    });
+    var _ref = FocusLock$1.propTypes || {};
+      _ref.sideCar;
+      _objectWithoutPropertiesLoose(_ref, ["sideCar"]);
+    FocusLockCombination.propTypes = {};
+
+    var FocusLock = React__namespace.default.forwardRef(function (_a) {
+        var restoreFocus = _a.restoreFocus, disabled = _a.disabled, children = _a.children;
+        return (jsxRuntime.jsx(FocusLockCombination, __assign({ returnFocus: restoreFocus, disabled: disabled, persistentFocus: false, autoFocus: false }, { children: children })));
+    });
+
+    exports.FocusLock = FocusLock;
+
+}));
+//# sourceMappingURL=ct-design-focus-lock.umd.js.map