@cleartrip/ct-design-focus-lock 2.1.0 → 2.2.0-beta.1

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

@@ -1,28 +1,13 @@
 (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';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react/jsx-runtime'), require('react-focus-lock'), require('react')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'react/jsx-runtime', 'react-focus-lock', 'react'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CTDesignSystemFocusLock = {}, global.jsxRuntime, global.ReactFocusLock, global.React));
+})(this, (function (exports, jsxRuntime, ReactFocusLock, React) { '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);
-    }
+    function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-    var React__namespace = /*#__PURE__*/_interopNamespace(React$1);
+    var ReactFocusLock__default = /*#__PURE__*/_interopDefault(ReactFocusLock);
+    var React__default = /*#__PURE__*/_interopDefault(React);
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -55,1631 +40,9 @@
       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 FocusLock = React__default.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 })));
+        return (jsxRuntime.jsx(ReactFocusLock__default.default, __assign({ returnFocus: restoreFocus, disabled: disabled, persistentFocus: false, autoFocus: false }, { children: children })));
     });
 
     exports.FocusLock = FocusLock;