@openviking/react 0.1.2 → 0.1.4

package/dist/2~0.js

@@ -0,0 +1,2360 @@
+/*! LICENSE: 2~0.js.LICENSE.txt */
+import { jsx, jsxs } from "react/jsx-runtime";
+import react, { Fragment, PureComponent, createContext, forwardRef, useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { CSSTransition } from "react-transition-group";
+import { __webpack_require__ } from "./rslib-runtime~0.js";
+import { resolveLocale } from "./nx~0.js";
+import { removereact } from "./4~0.js";
+import { usePortalTheme } from "./9~0.js";
+import { AgentConnect } from "./u~0.js";
+import * as __rspack_external_react from "react";
+__webpack_require__.add({
+    N (module) {
+        /*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/ var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+        var hasOwnProperty = Object.prototype.hasOwnProperty;
+        var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+        function toObject(val) {
+            if (null == val) throw new TypeError('Object.assign cannot be called with null or undefined');
+            return Object(val);
+        }
+        function shouldUseNative() {
+            try {
+                if (!Object.assign) return false;
+                var test1 = new String('abc');
+                test1[5] = 'de';
+                if ('5' === Object.getOwnPropertyNames(test1)[0]) return false;
+                var test2 = {};
+                for(var i = 0; i < 10; i++)test2['_' + String.fromCharCode(i)] = i;
+                var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+                    return test2[n];
+                });
+                if ('0123456789' !== order2.join('')) return false;
+                var test3 = {};
+                'abcdefghijklmnopqrst'.split('').forEach(function(letter) {
+                    test3[letter] = letter;
+                });
+                if ('abcdefghijklmnopqrst' !== Object.keys(Object.assign({}, test3)).join('')) return false;
+                return true;
+            } catch (err) {
+                return false;
+            }
+        }
+        module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+            var from;
+            var to = toObject(target);
+            var symbols;
+            for(var s = 1; s < arguments.length; s++){
+                from = Object(arguments[s]);
+                for(var key in from)if (hasOwnProperty.call(from, key)) to[key] = from[key];
+                if (getOwnPropertySymbols) {
+                    symbols = getOwnPropertySymbols(from);
+                    for(var i = 0; i < symbols.length; i++)if (propIsEnumerable.call(from, symbols[i])) to[symbols[i]] = from[symbols[i]];
+                }
+            }
+            return to;
+        };
+    },
+    G (module, __unused_rspack_exports, __webpack_require__) {
+        var printWarning = function() {};
+        if ('production' !== process.env.NODE_ENV) {
+            var ReactPropTypesSecret = __webpack_require__("y");
+            var loggedTypeFailures = {};
+            var has = __webpack_require__("x");
+            printWarning = function(text) {
+                var message = 'Warning: ' + text;
+                if ("u" > typeof console) console.error(message);
+                try {
+                    throw new Error(message);
+                } catch (x) {}
+            };
+        }
+        function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+            if ('production' !== process.env.NODE_ENV) {
+                for(var typeSpecName in typeSpecs)if (has(typeSpecs, typeSpecName)) {
+                    var error;
+                    try {
+                        if ('function' != typeof typeSpecs[typeSpecName]) {
+                            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                            err.name = 'Invariant Violation';
+                            throw err;
+                        }
+                        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+                    } catch (ex) {
+                        error = ex;
+                    }
+                    if (error && !(error instanceof Error)) printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).");
+                    if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+                        loggedTypeFailures[error.message] = true;
+                        var stack = getStack ? getStack() : '';
+                        printWarning('Failed ' + location + ' type: ' + error.message + (null != stack ? stack : ''));
+                    }
+                }
+            }
+        }
+        checkPropTypes.resetWarningCache = function() {
+            if ('production' !== process.env.NODE_ENV) loggedTypeFailures = {};
+        };
+        module.exports = checkPropTypes;
+    },
+    S (module, __unused_rspack_exports, __webpack_require__) {
+        var ReactPropTypesSecret = __webpack_require__("y");
+        function emptyFunction() {}
+        function emptyFunctionWithReset() {}
+        emptyFunctionWithReset.resetWarningCache = emptyFunction;
+        module.exports = function() {
+            function shim(props, propName, componentName, location, propFullName, secret) {
+                if (secret === ReactPropTypesSecret) 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;
+            }
+            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;
+        };
+    },
+    IH (module, __unused_rspack_exports, __webpack_require__) {
+        var ReactIs = __webpack_require__("vJ");
+        var assign = __webpack_require__("N");
+        var ReactPropTypesSecret = __webpack_require__("y");
+        var has = __webpack_require__("x");
+        var checkPropTypes = __webpack_require__("G");
+        var printWarning = function() {};
+        if ('production' !== process.env.NODE_ENV) printWarning = function(text) {
+            var message = 'Warning: ' + text;
+            if ("u" > typeof console) console.error(message);
+            try {
+                throw new Error(message);
+            } catch (x) {}
+        };
+        function emptyFunctionThatReturnsNull() {
+            return null;
+        }
+        module.exports = function(isValidElement, throwOnDirectAccess) {
+            var ITERATOR_SYMBOL = 'function' == typeof Symbol && Symbol.iterator;
+            var FAUX_ITERATOR_SYMBOL = '@@iterator';
+            function getIteratorFn(maybeIterable) {
+                var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+                if ('function' == typeof iteratorFn) return iteratorFn;
+            }
+            var ANONYMOUS = '<<anonymous>>';
+            var ReactPropTypes = {
+                array: createPrimitiveTypeChecker('array'),
+                bigint: createPrimitiveTypeChecker('bigint'),
+                bool: createPrimitiveTypeChecker('boolean'),
+                func: createPrimitiveTypeChecker('function'),
+                number: createPrimitiveTypeChecker('number'),
+                object: createPrimitiveTypeChecker('object'),
+                string: createPrimitiveTypeChecker('string'),
+                symbol: createPrimitiveTypeChecker('symbol'),
+                any: createAnyTypeChecker(),
+                arrayOf: createArrayOfTypeChecker,
+                element: createElementTypeChecker(),
+                elementType: createElementTypeTypeChecker(),
+                instanceOf: createInstanceTypeChecker,
+                node: createNodeChecker(),
+                objectOf: createObjectOfTypeChecker,
+                oneOf: createEnumTypeChecker,
+                oneOfType: createUnionTypeChecker,
+                shape: createShapeTypeChecker,
+                exact: createStrictShapeTypeChecker
+            };
+            function is(x, y) {
+                if (x === y) return 0 !== x || 1 / x === 1 / y;
+                else return x !== x && y !== y;
+            }
+            function PropTypeError(message, data) {
+                this.message = message;
+                this.data = data && 'object' == typeof data ? data : {};
+                this.stack = '';
+            }
+            PropTypeError.prototype = Error.prototype;
+            function createChainableTypeChecker(validate) {
+                if ('production' !== process.env.NODE_ENV) {
+                    var manualPropTypeCallCache = {};
+                    var manualPropTypeWarningCount = 0;
+                }
+                function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+                    componentName = componentName || ANONYMOUS;
+                    propFullName = propFullName || propName;
+                    if (secret !== ReactPropTypesSecret) {
+                        if (throwOnDirectAccess) {
+                            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;
+                        } else if ('production' !== process.env.NODE_ENV && "u" > typeof console) {
+                            var cacheKey = componentName + ':' + propName;
+                            if (!manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3) {
+                                printWarning("You are manually calling a React.PropTypes validation function for the `" + propFullName + '` prop on `' + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details.");
+                                manualPropTypeCallCache[cacheKey] = true;
+                                manualPropTypeWarningCount++;
+                            }
+                        }
+                    }
+                    if (null != props[propName]) return validate(props, propName, componentName, location, propFullName);
+                    else {
+                        if (isRequired) {
+                            if (null === props[propName]) return new PropTypeError('The ' + location + ' `' + propFullName + "` is marked as required in `" + componentName + '`, but its value is `null`.');
+                            return new PropTypeError('The ' + location + ' `' + propFullName + "` is marked as required in `" + componentName + '`, but its value is `undefined`.');
+                        }
+                        return null;
+                    }
+                }
+                var chainedCheckType = checkType.bind(null, false);
+                chainedCheckType.isRequired = checkType.bind(null, true);
+                return chainedCheckType;
+            }
+            function createPrimitiveTypeChecker(expectedType) {
+                function validate(props, propName, componentName, location, propFullName, secret) {
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+                    if (propType !== expectedType) {
+                        var preciseType = getPreciseType(propValue);
+                        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `') + componentName + "`, expected `" + expectedType + '`.', {
+                            expectedType: expectedType
+                        });
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createAnyTypeChecker() {
+                return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+            }
+            function createArrayOfTypeChecker(typeChecker) {
+                function validate(props, propName, componentName, location, propFullName) {
+                    if ('function' != typeof typeChecker) return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+                    var propValue = props[propName];
+                    if (!Array.isArray(propValue)) {
+                        var propType = getPropType(propValue);
+                        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `') + componentName + '`, expected an array.');
+                    }
+                    for(var i = 0; i < propValue.length; i++){
+                        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+                        if (error instanceof Error) return error;
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createElementTypeChecker() {
+                function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    if (!isValidElement(propValue)) {
+                        var propType = getPropType(propValue);
+                        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `') + componentName + '`, expected a single ReactElement.');
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createElementTypeTypeChecker() {
+                function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    if (!ReactIs.isValidElementType(propValue)) {
+                        var propType = getPropType(propValue);
+                        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `') + componentName + '`, expected a single ReactElement type.');
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createInstanceTypeChecker(expectedClass) {
+                function validate(props, propName, componentName, location, propFullName) {
+                    if (!(props[propName] instanceof expectedClass)) {
+                        var expectedClassName = expectedClass.name || ANONYMOUS;
+                        var actualClassName = getClassName(props[propName]);
+                        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `') + componentName + "`, expected instance of `" + expectedClassName + '`.');
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createEnumTypeChecker(expectedValues) {
+                if (!Array.isArray(expectedValues)) {
+                    if ('production' !== process.env.NODE_ENV) arguments.length > 1 ? printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).") : printWarning('Invalid argument supplied to oneOf, expected an array.');
+                    return emptyFunctionThatReturnsNull;
+                }
+                function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    for(var i = 0; i < expectedValues.length; i++)if (is(propValue, expectedValues[i])) return null;
+                    var valuesString = JSON.stringify(expectedValues, function(key, value) {
+                        var type = getPreciseType(value);
+                        if ('symbol' === type) return String(value);
+                        return value;
+                    });
+                    return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ') + valuesString + '.');
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createObjectOfTypeChecker(typeChecker) {
+                function validate(props, propName, componentName, location, propFullName) {
+                    if ('function' != typeof typeChecker) return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+                    if ('object' !== propType) return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `') + componentName + '`, expected an object.');
+                    for(var key in propValue)if (has(propValue, key)) {
+                        var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+                        if (error instanceof Error) return error;
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createUnionTypeChecker(arrayOfTypeCheckers) {
+                if (!Array.isArray(arrayOfTypeCheckers)) {
+                    'production' !== process.env.NODE_ENV && printWarning('Invalid argument supplied to oneOfType, expected an instance of array.');
+                    return emptyFunctionThatReturnsNull;
+                }
+                for(var i = 0; i < arrayOfTypeCheckers.length; i++){
+                    var checker = arrayOfTypeCheckers[i];
+                    if ('function' != typeof checker) {
+                        printWarning("Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
+                        return emptyFunctionThatReturnsNull;
+                    }
+                }
+                function validate(props, propName, componentName, location, propFullName) {
+                    var expectedTypes = [];
+                    for(var i = 0; i < arrayOfTypeCheckers.length; i++){
+                        var checker = arrayOfTypeCheckers[i];
+                        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+                        if (null == checkerResult) return null;
+                        if (checkerResult.data && has(checkerResult.data, 'expectedType')) expectedTypes.push(checkerResult.data.expectedType);
+                    }
+                    var expectedTypesMessage = expectedTypes.length > 0 ? ', expected one of type [' + expectedTypes.join(', ') + ']' : '';
+                    return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`') + expectedTypesMessage + '.');
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createNodeChecker() {
+                function validate(props, propName, componentName, location, propFullName) {
+                    if (!isNode(props[propName])) return new PropTypeError('Invalid ' + location + ' `' + propFullName + "` supplied to `" + componentName + '`, expected a ReactNode.');
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function invalidValidatorError(componentName, location, propFullName, key, type) {
+                return new PropTypeError((componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + '`.');
+            }
+            function createShapeTypeChecker(shapeTypes) {
+                function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+                    if ('object' !== propType) return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + "` supplied to `" + componentName + '`, expected `object`.');
+                    for(var key in shapeTypes){
+                        var checker = shapeTypes[key];
+                        if ('function' != typeof checker) return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+                        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+                        if (error) return error;
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function createStrictShapeTypeChecker(shapeTypes) {
+                function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+                    if ('object' !== propType) return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + "` supplied to `" + componentName + '`, expected `object`.');
+                    var allKeys = assign({}, props[propName], shapeTypes);
+                    for(var key in allKeys){
+                        var checker = shapeTypes[key];
+                        if (has(shapeTypes, key) && 'function' != typeof checker) return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+                        if (!checker) return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, '  ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  '));
+                        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+                        if (error) return error;
+                    }
+                    return null;
+                }
+                return createChainableTypeChecker(validate);
+            }
+            function isNode(propValue) {
+                switch(typeof propValue){
+                    case 'number':
+                    case 'string':
+                    case 'undefined':
+                        return true;
+                    case 'boolean':
+                        return !propValue;
+                    case 'object':
+                        if (Array.isArray(propValue)) return propValue.every(isNode);
+                        if (null === propValue || isValidElement(propValue)) return true;
+                        var iteratorFn = getIteratorFn(propValue);
+                        if (!iteratorFn) return false;
+                        else {
+                            var iterator = iteratorFn.call(propValue);
+                            var step;
+                            if (iteratorFn !== propValue.entries) {
+                                while(!(step = iterator.next()).done)if (!isNode(step.value)) return false;
+                            } else while(!(step = iterator.next()).done){
+                                var entry = step.value;
+                                if (entry) {
+                                    if (!isNode(entry[1])) return false;
+                                }
+                            }
+                        }
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+            function isSymbol(propType, propValue) {
+                if ('symbol' === propType) return true;
+                if (!propValue) return false;
+                if ('Symbol' === propValue['@@toStringTag']) return true;
+                if ('function' == typeof Symbol && propValue instanceof Symbol) return true;
+                return false;
+            }
+            function getPropType(propValue) {
+                var propType = typeof propValue;
+                if (Array.isArray(propValue)) return 'array';
+                if (propValue instanceof RegExp) return 'object';
+                if (isSymbol(propType, propValue)) return 'symbol';
+                return propType;
+            }
+            function getPreciseType(propValue) {
+                if (null == propValue) return '' + propValue;
+                var propType = getPropType(propValue);
+                if ('object' === propType) {
+                    if (propValue instanceof Date) return 'date';
+                    else if (propValue instanceof RegExp) return 'regexp';
+                }
+                return propType;
+            }
+            function getPostfixForTypeWarning(value) {
+                var type = getPreciseType(value);
+                switch(type){
+                    case 'array':
+                    case 'object':
+                        return 'an ' + type;
+                    case 'boolean':
+                    case 'date':
+                    case 'regexp':
+                        return 'a ' + type;
+                    default:
+                        return type;
+                }
+            }
+            function getClassName(propValue) {
+                if (!propValue.constructor || !propValue.constructor.name) return ANONYMOUS;
+                return propValue.constructor.name;
+            }
+            ReactPropTypes.checkPropTypes = checkPropTypes;
+            ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+            ReactPropTypes.PropTypes = ReactPropTypes;
+            return ReactPropTypes;
+        };
+    },
+    i (module, __unused_rspack_exports, __webpack_require__) {
+        if ('production' !== process.env.NODE_ENV) {
+            var ReactIs = __webpack_require__("vJ");
+            var throwOnDirectAccess = true;
+            module.exports = __webpack_require__("IH")(ReactIs.isElement, throwOnDirectAccess);
+        } else module.exports = __webpack_require__("S")();
+    },
+    y (module) {
+        var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+        module.exports = ReactPropTypesSecret;
+    },
+    x (module) {
+        module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+    },
+    V (__unused_rspack_module, exports) {
+        /** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ if ("production" !== process.env.NODE_ENV) (function() {
+            'use strict';
+            var hasSymbol = 'function' == typeof Symbol && Symbol.for;
+            var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+            var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+            var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+            var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+            var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+            var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+            var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;
+            var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+            var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+            var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+            var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+            var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+            var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+            var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+            var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+            var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+            var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+            var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+            function isValidElementType(type) {
+                return 'string' == typeof type || 'function' == typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || 'object' == typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+            }
+            function typeOf(object) {
+                if ('object' == typeof object && null !== object) {
+                    var $$typeof = object.$$typeof;
+                    switch($$typeof){
+                        case REACT_ELEMENT_TYPE:
+                            var type = object.type;
+                            switch(type){
+                                case REACT_ASYNC_MODE_TYPE:
+                                case REACT_CONCURRENT_MODE_TYPE:
+                                case REACT_FRAGMENT_TYPE:
+                                case REACT_PROFILER_TYPE:
+                                case REACT_STRICT_MODE_TYPE:
+                                case REACT_SUSPENSE_TYPE:
+                                    return type;
+                                default:
+                                    var $$typeofType = type && type.$$typeof;
+                                    switch($$typeofType){
+                                        case REACT_CONTEXT_TYPE:
+                                        case REACT_FORWARD_REF_TYPE:
+                                        case REACT_LAZY_TYPE:
+                                        case REACT_MEMO_TYPE:
+                                        case REACT_PROVIDER_TYPE:
+                                            return $$typeofType;
+                                        default:
+                                            return $$typeof;
+                                    }
+                            }
+                        case REACT_PORTAL_TYPE:
+                            return $$typeof;
+                    }
+                }
+            }
+            var AsyncMode = REACT_ASYNC_MODE_TYPE;
+            var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+            var ContextConsumer = REACT_CONTEXT_TYPE;
+            var ContextProvider = REACT_PROVIDER_TYPE;
+            var Element = REACT_ELEMENT_TYPE;
+            var ForwardRef = REACT_FORWARD_REF_TYPE;
+            var Fragment = REACT_FRAGMENT_TYPE;
+            var Lazy = REACT_LAZY_TYPE;
+            var Memo = REACT_MEMO_TYPE;
+            var Portal = REACT_PORTAL_TYPE;
+            var Profiler = REACT_PROFILER_TYPE;
+            var StrictMode = REACT_STRICT_MODE_TYPE;
+            var Suspense = REACT_SUSPENSE_TYPE;
+            var hasWarnedAboutDeprecatedIsAsyncMode = false;
+            function isAsyncMode(object) {
+                if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+                    hasWarnedAboutDeprecatedIsAsyncMode = true;
+                    console['warn']("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
+                }
+                return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+            }
+            function isConcurrentMode(object) {
+                return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+            }
+            function isContextConsumer(object) {
+                return typeOf(object) === REACT_CONTEXT_TYPE;
+            }
+            function isContextProvider(object) {
+                return typeOf(object) === REACT_PROVIDER_TYPE;
+            }
+            function isElement(object) {
+                return 'object' == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+            }
+            function isForwardRef(object) {
+                return typeOf(object) === REACT_FORWARD_REF_TYPE;
+            }
+            function isFragment(object) {
+                return typeOf(object) === REACT_FRAGMENT_TYPE;
+            }
+            function isLazy(object) {
+                return typeOf(object) === REACT_LAZY_TYPE;
+            }
+            function isMemo(object) {
+                return typeOf(object) === REACT_MEMO_TYPE;
+            }
+            function isPortal(object) {
+                return typeOf(object) === REACT_PORTAL_TYPE;
+            }
+            function isProfiler(object) {
+                return typeOf(object) === REACT_PROFILER_TYPE;
+            }
+            function isStrictMode(object) {
+                return typeOf(object) === REACT_STRICT_MODE_TYPE;
+            }
+            function isSuspense(object) {
+                return typeOf(object) === REACT_SUSPENSE_TYPE;
+            }
+            exports.AsyncMode = AsyncMode;
+            exports.ConcurrentMode = ConcurrentMode;
+            exports.ContextConsumer = ContextConsumer;
+            exports.ContextProvider = ContextProvider;
+            exports.Element = Element;
+            exports.ForwardRef = ForwardRef;
+            exports.Fragment = Fragment;
+            exports.Lazy = Lazy;
+            exports.Memo = Memo;
+            exports.Portal = Portal;
+            exports.Profiler = Profiler;
+            exports.StrictMode = StrictMode;
+            exports.Suspense = Suspense;
+            exports.isAsyncMode = isAsyncMode;
+            exports.isConcurrentMode = isConcurrentMode;
+            exports.isContextConsumer = isContextConsumer;
+            exports.isContextProvider = isContextProvider;
+            exports.isElement = isElement;
+            exports.isForwardRef = isForwardRef;
+            exports.isFragment = isFragment;
+            exports.isLazy = isLazy;
+            exports.isMemo = isMemo;
+            exports.isPortal = isPortal;
+            exports.isProfiler = isProfiler;
+            exports.isStrictMode = isStrictMode;
+            exports.isSuspense = isSuspense;
+            exports.isValidElementType = isValidElementType;
+            exports.typeOf = typeOf;
+        })();
+    },
+    l (__unused_rspack_module, exports) {
+        /** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ var b = "function" == typeof Symbol && Symbol.for, c = b ? Symbol.for("react.element") : 60103, d = b ? Symbol.for("react.portal") : 60106, e = b ? Symbol.for("react.fragment") : 60107, f = b ? Symbol.for("react.strict_mode") : 60108, g = b ? Symbol.for("react.profiler") : 60114, h = b ? Symbol.for("react.provider") : 60109, k = b ? Symbol.for("react.context") : 60110, l = b ? Symbol.for("react.async_mode") : 60111, m = b ? Symbol.for("react.concurrent_mode") : 60111, n = b ? Symbol.for("react.forward_ref") : 60112, p = b ? Symbol.for("react.suspense") : 60113, q = b ? Symbol.for("react.suspense_list") : 60120, r = b ? Symbol.for("react.memo") : 60115, t = b ? Symbol.for("react.lazy") : 60116, v = b ? Symbol.for("react.block") : 60121, w = b ? Symbol.for("react.fundamental") : 60117, x = b ? Symbol.for("react.responder") : 60118, y = b ? Symbol.for("react.scope") : 60119;
+        function z(a) {
+            if ("object" == typeof a && null !== a) {
+                var u = a.$$typeof;
+                switch(u){
+                    case c:
+                        switch(a = a.type){
+                            case l:
+                            case m:
+                            case e:
+                            case g:
+                            case f:
+                            case p:
+                                return a;
+                            default:
+                                switch(a = a && a.$$typeof){
+                                    case k:
+                                    case n:
+                                    case t:
+                                    case r:
+                                    case h:
+                                        return a;
+                                    default:
+                                        return u;
+                                }
+                        }
+                    case d:
+                        return u;
+                }
+            }
+        }
+        function A(a) {
+            return z(a) === m;
+        }
+        exports.AsyncMode = l;
+        exports.ConcurrentMode = m;
+        exports.ContextConsumer = k;
+        exports.ContextProvider = h;
+        exports.Element = c;
+        exports.ForwardRef = n;
+        exports.Fragment = e;
+        exports.Lazy = t;
+        exports.Memo = r;
+        exports.Portal = d;
+        exports.Profiler = g;
+        exports.StrictMode = f;
+        exports.Suspense = p;
+        exports.isAsyncMode = function(a) {
+            return A(a) || z(a) === l;
+        };
+        exports.isConcurrentMode = A;
+        exports.isContextConsumer = function(a) {
+            return z(a) === k;
+        };
+        exports.isContextProvider = function(a) {
+            return z(a) === h;
+        };
+        exports.isElement = function(a) {
+            return "object" == typeof a && null !== a && a.$$typeof === c;
+        };
+        exports.isForwardRef = function(a) {
+            return z(a) === n;
+        };
+        exports.isFragment = function(a) {
+            return z(a) === e;
+        };
+        exports.isLazy = function(a) {
+            return z(a) === t;
+        };
+        exports.isMemo = function(a) {
+            return z(a) === r;
+        };
+        exports.isPortal = function(a) {
+            return z(a) === d;
+        };
+        exports.isProfiler = function(a) {
+            return z(a) === g;
+        };
+        exports.isStrictMode = function(a) {
+            return z(a) === f;
+        };
+        exports.isSuspense = function(a) {
+            return z(a) === p;
+        };
+        exports.isValidElementType = function(a) {
+            return "string" == typeof a || "function" == typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" == typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+        };
+        exports.typeOf = z;
+    },
+    vJ (module, __unused_rspack_exports, __webpack_require__) {
+        if ('production' === process.env.NODE_ENV) module.exports = __webpack_require__("l");
+        else module.exports = __webpack_require__("V");
+    }
+});
+const messages = {
+    close: 'Close',
+    connectAgent: 'Connect agent',
+    importResources: 'Import resources'
+};
+const en_US = messages;
+const zh_CN_messages = {
+    close: '关闭',
+    connectAgent: '连接 Agent',
+    importResources: '导入资源'
+};
+const zh_CN = zh_CN_messages;
+const LOCALES = {
+    'en-US': en_US,
+    'zh-CN': zh_CN
+};
+function resolveFileBrowserEntriesLabels(locale, labels) {
+    return resolveLocale(LOCALES, locale, labels);
+}
+function Divider({ orientation = 'vertical', length, thickness = 1, color, className, style, ...rest }) {
+    const vertical = 'vertical' === orientation;
+    const size = vertical ? {
+        flex: 'none',
+        width: thickness,
+        height: length
+    } : {
+        flex: 'none',
+        width: length ?? '100%',
+        height: thickness
+    };
+    return /*#__PURE__*/ jsx("div", {
+        ...rest,
+        role: "separator",
+        "aria-orientation": orientation,
+        className: [
+            'ov-divider',
+            className
+        ].filter(Boolean).join(' '),
+        style: {
+            background: color ?? 'var(--ov-ui-color-border-2, var(--ov-ui-border-2-default, #e1e4f2))',
+            ...size,
+            ...style
+        }
+    });
+}
+function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for(var n in r)if (({}).hasOwnProperty.call(r, n)) {
+        if (-1 !== e.indexOf(n)) continue;
+        t[n] = r[n];
+    }
+    return t;
+}
+function _extends() {
+    return _extends = Object.assign ? Object.assign.bind() : function(n) {
+        for(var e = 1; e < arguments.length; e++){
+            var t = arguments[e];
+            for(var r in t)({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+        }
+        return n;
+    }, _extends.apply(null, arguments);
+}
+var FOCUS_GROUP = 'data-focus-lock';
+var FOCUS_DISABLED = 'data-focus-lock-disabled';
+var FOCUS_ALLOW = 'data-no-focus-lock';
+var FOCUS_AUTO = 'data-autofocus-inside';
+var FOCUS_NO_AUTOFOCUS = 'data-no-autofocus';
+function assignRef(ref, value) {
+    if ('function' == typeof ref) ref(value);
+    else if (ref) ref.current = value;
+    return ref;
+}
+function useCallbackRef(initialValue, callback) {
+    var ref = useState(function() {
+        return {
+            value: initialValue,
+            callback: callback,
+            facade: {
+                get current () {
+                    return ref.value;
+                },
+                set current (value){
+                    var last = ref.value;
+                    if (last !== value) {
+                        ref.value = value;
+                        ref.callback(value, last);
+                    }
+                }
+            }
+        };
+    })[0];
+    ref.callback = callback;
+    return ref.facade;
+}
+var useIsomorphicLayoutEffect = "u" > typeof window ? __rspack_external_react.useLayoutEffect : __rspack_external_react.useEffect;
+var currentValues = new WeakMap();
+function useMergeRefs(refs, defaultValue) {
+    var callbackRef = useCallbackRef(defaultValue || null, function(newValue) {
+        return refs.forEach(function(ref) {
+            return assignRef(ref, newValue);
+        });
+    });
+    useIsomorphicLayoutEffect(function() {
+        var oldValue = currentValues.get(callbackRef);
+        if (oldValue) {
+            var prevRefs_1 = new Set(oldValue);
+            var nextRefs_1 = new Set(refs);
+            var current_1 = callbackRef.current;
+            prevRefs_1.forEach(function(ref) {
+                if (!nextRefs_1.has(ref)) assignRef(ref, null);
+            });
+            nextRefs_1.forEach(function(ref) {
+                if (!prevRefs_1.has(ref)) assignRef(ref, current_1);
+            });
+        }
+        currentValues.set(callbackRef, refs);
+    }, [
+        refs
+    ]);
+    return callbackRef;
+}
+const prop_types = __webpack_require__("i");
+var prop_types_default = /*#__PURE__*/ __webpack_require__.n(prop_types);
+var hiddenGuard = {
+    width: '1px',
+    height: '0px',
+    padding: 0,
+    overflow: 'hidden',
+    position: 'fixed',
+    top: '1px',
+    left: '1px'
+};
+var FocusGuard_InFocusGuard = function(_ref) {
+    var _ref$children = _ref.children, children = void 0 === _ref$children ? null : _ref$children;
+    return /*#__PURE__*/ react.createElement(Fragment, null, /*#__PURE__*/ react.createElement("div", {
+        key: "guard-first",
+        "data-focus-guard": true,
+        "data-focus-auto-guard": true,
+        style: hiddenGuard
+    }), children, children && /*#__PURE__*/ react.createElement("div", {
+        key: "guard-last",
+        "data-focus-guard": true,
+        "data-focus-auto-guard": true,
+        style: hiddenGuard
+    }));
+};
+FocusGuard_InFocusGuard.propTypes = "production" !== process.env.NODE_ENV ? {
+    children: prop_types_default().node
+} : {};
+var tslib_es6_assign = function() {
+    tslib_es6_assign = Object.assign || function(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 tslib_es6_assign.apply(this, arguments);
+};
+function ItoI(a) {
+    return a;
+}
+function innerCreateMedium(defaults, middleware) {
+    if (void 0 === middleware) 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 (void 0 === middleware) middleware = ItoI;
+    return innerCreateMedium(defaults, middleware);
+}
+function createSidecarMedium(options) {
+    if (void 0 === options) options = {};
+    var medium = innerCreateMedium(null);
+    medium.options = tslib_es6_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,
+    ssr: "u" > typeof document
+});
+var focusScope = /*#__PURE__*/ createContext(void 0);
+var emptyArray = [];
+var FocusLock = /*#__PURE__*/ forwardRef(function(props, parentRef) {
+    var _extends2;
+    var _useState = useState(), realObserved = _useState[0], setObserved = _useState[1];
+    var observed = useRef();
+    var isActive = useRef(false);
+    var originalFocusedElement = useRef(null);
+    var _useState2 = useState({}), update = _useState2[1];
+    var children = props.children, _props$disabled = props.disabled, disabled = void 0 === _props$disabled ? false : _props$disabled, _props$noFocusGuards = props.noFocusGuards, noFocusGuards = void 0 === _props$noFocusGuards ? false : _props$noFocusGuards, _props$persistentFocu = props.persistentFocus, persistentFocus = void 0 === _props$persistentFocu ? false : _props$persistentFocu, _props$crossFrame = props.crossFrame, crossFrame = void 0 === _props$crossFrame ? true : _props$crossFrame, _props$autoFocus = props.autoFocus, autoFocus = void 0 === _props$autoFocus ? true : _props$autoFocus, allowTextSelection = props.allowTextSelection, group = props.group, className = props.className, whiteList = props.whiteList, hasPositiveIndices = props.hasPositiveIndices, _props$shards = props.shards, shards = void 0 === _props$shards ? emptyArray : _props$shards, _props$as = props.as, Container = void 0 === _props$as ? 'div' : _props$as, _props$lockProps = props.lockProps, containerProps = void 0 === _props$lockProps ? {} : _props$lockProps, SideCar = props.sideCar, _props$returnFocus = props.returnFocus, shouldReturnFocus = void 0 === _props$returnFocus ? false : _props$returnFocus, focusOptions = props.focusOptions, onActivationCallback = props.onActivation, onDeactivationCallback = props.onDeactivation;
+    var _useState3 = useState({}), id = _useState3[0];
+    var onActivation = useCallback(function(_ref) {
+        var captureFocusRestore = _ref.captureFocusRestore;
+        if (!originalFocusedElement.current) {
+            var _document;
+            var activeElement = null == (_document = document) ? void 0 : _document.activeElement;
+            originalFocusedElement.current = activeElement;
+            if (activeElement !== document.body) originalFocusedElement.current = captureFocusRestore(activeElement);
+        }
+        if (observed.current && onActivationCallback) onActivationCallback(observed.current);
+        isActive.current = true;
+        update();
+    }, [
+        onActivationCallback
+    ]);
+    var onDeactivation = useCallback(function() {
+        isActive.current = false;
+        if (onDeactivationCallback) onDeactivationCallback(observed.current);
+        update();
+    }, [
+        onDeactivationCallback
+    ]);
+    var returnFocus = useCallback(function(allowDefer) {
+        var focusRestore = originalFocusedElement.current;
+        if (focusRestore) {
+            var returnFocusTo = ('function' == typeof focusRestore ? focusRestore() : focusRestore) || document.body;
+            var howToReturnFocus = 'function' == typeof shouldReturnFocus ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;
+            if (howToReturnFocus) {
+                var returnFocusOptions = 'object' == typeof howToReturnFocus ? howToReturnFocus : void 0;
+                originalFocusedElement.current = null;
+                if (allowDefer) Promise.resolve().then(function() {
+                    return returnFocusTo.focus(returnFocusOptions);
+                });
+                else returnFocusTo.focus(returnFocusOptions);
+            }
+        }
+    }, [
+        shouldReturnFocus
+    ]);
+    var onFocus = useCallback(function(event) {
+        if (isActive.current) mediumFocus.useMedium(event);
+    }, []);
+    var onBlur = mediumBlur.useMedium;
+    var setObserveNode = useCallback(function(newObserved) {
+        if (observed.current !== newObserved) {
+            observed.current = newObserved;
+            setObserved(newObserved);
+        }
+    }, []);
+    if ('production' !== process.env.NODE_ENV) {
+        if (void 0 !== allowTextSelection) console.warn('React-Focus-Lock: allowTextSelection is deprecated and enabled by default');
+        useEffect(function() {
+            if (!observed.current && 'string' != typeof Container) console.error('FocusLock: could not obtain ref to internal node');
+        }, []);
+    }
+    var lockProps = _extends((_extends2 = {}, _extends2[FOCUS_DISABLED] = disabled && 'disabled', _extends2[FOCUS_GROUP] = group, _extends2), containerProps);
+    var hasLeadingGuards = true !== noFocusGuards;
+    var hasTailingGuards = hasLeadingGuards && 'tail' !== noFocusGuards;
+    var mergedRef = useMergeRefs([
+        parentRef,
+        setObserveNode
+    ]);
+    var focusScopeValue = useMemo(function() {
+        return {
+            observed: observed,
+            shards: shards,
+            enabled: !disabled,
+            get active () {
+                return isActive.current;
+            }
+        };
+    }, [
+        disabled,
+        isActive,
+        shards,
+        observed
+    ]);
+    return /*#__PURE__*/ react.createElement(Fragment, null, hasLeadingGuards && [
+        /*#__PURE__*/ react.createElement("div", {
+            key: "guard-first",
+            "data-focus-guard": true,
+            tabIndex: disabled ? -1 : 0,
+            style: hiddenGuard
+        }),
+        hasPositiveIndices ? /*#__PURE__*/ react.createElement("div", {
+            key: "guard-nearest",
+            "data-focus-guard": true,
+            tabIndex: disabled ? -1 : 1,
+            style: hiddenGuard
+        }) : null
+    ], !disabled && /*#__PURE__*/ react.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,
+        noFocusGuards: noFocusGuards
+    }), /*#__PURE__*/ react.createElement(Container, _extends({
+        ref: mergedRef
+    }, lockProps, {
+        className: className,
+        onBlur: onBlur,
+        onFocus: onFocus
+    }), /*#__PURE__*/ react.createElement(focusScope.Provider, {
+        value: focusScopeValue
+    }, children)), hasTailingGuards && /*#__PURE__*/ react.createElement("div", {
+        "data-focus-guard": true,
+        tabIndex: disabled ? -1 : 0,
+        style: hiddenGuard
+    }));
+});
+FocusLock.propTypes = "production" !== process.env.NODE_ENV ? {
+    children: prop_types.node,
+    disabled: prop_types.bool,
+    returnFocus: (0, prop_types.oneOfType)([
+        prop_types.bool,
+        prop_types.object,
+        prop_types.func
+    ]),
+    focusOptions: prop_types.object,
+    noFocusGuards: prop_types.bool,
+    hasPositiveIndices: prop_types.bool,
+    allowTextSelection: prop_types.bool,
+    autoFocus: prop_types.bool,
+    persistentFocus: prop_types.bool,
+    crossFrame: prop_types.bool,
+    group: prop_types.string,
+    className: prop_types.string,
+    whiteList: prop_types.func,
+    shards: (0, prop_types.arrayOf)(prop_types.any),
+    as: (0, prop_types.oneOfType)([
+        prop_types.string,
+        prop_types.func,
+        prop_types.object
+    ]),
+    lockProps: prop_types.object,
+    onActivation: prop_types.func,
+    onDeactivation: prop_types.func,
+    sideCar: prop_types.any.isRequired
+} : {};
+const Lock = FocusLock;
+function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t, e) {
+        return t.__proto__ = e, t;
+    }, _setPrototypeOf(t, e);
+}
+function _inheritsLoose(t, o) {
+    t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _typeof(o) {
+    return _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;
+    }, _typeof(o);
+}
+function toPrimitive(t, e) {
+    if ("object" != _typeof(t) || !t) return t;
+    var r;
+    if ("u" > typeof Symbol && void 0 !== (r = t[Symbol.toPrimitive])) {
+        var i = r.call(t, e || "default");
+        if ("object" != _typeof(i)) return i;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === e ? String : Number)(t);
+}
+function toPropertyKey(t) {
+    var i = toPrimitive(t, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+        value: t,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : e[r] = t, e;
+}
+function withSideEffect(reducePropsToState, handleStateChangeOnClient) {
+    if ("production" !== process.env.NODE_ENV) {
+        if ('function' != typeof reducePropsToState) throw new Error('Expected reducePropsToState to be a function.');
+        if ('function' != typeof handleStateChangeOnClient) throw new Error('Expected handleStateChangeOnClient to be a function.');
+    }
+    function getDisplayName(WrappedComponent) {
+        return WrappedComponent.displayName || WrappedComponent.name || 'Component';
+    }
+    return function(WrappedComponent) {
+        if ("production" !== process.env.NODE_ENV) {
+            if ('function' != typeof WrappedComponent) throw new Error('Expected WrappedComponent to be a React component.');
+        }
+        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;
+            }
+            SideEffect.peek = function() {
+                return state;
+            };
+            var _proto = SideEffect.prototype;
+            _proto.componentDidMount = function() {
+                mountedInstances.push(this);
+                emitChange();
+            };
+            _proto.componentDidUpdate = function() {
+                emitChange();
+            };
+            _proto.componentWillUnmount = function() {
+                var index = mountedInstances.indexOf(this);
+                mountedInstances.splice(index, 1);
+                emitChange();
+            };
+            _proto.render = function() {
+                return /*#__PURE__*/ react.createElement(WrappedComponent, this.props);
+            };
+            return SideEffect;
+        }(PureComponent);
+        _defineProperty(SideEffect, "displayName", "SideEffect(" + getDisplayName(WrappedComponent) + ")");
+        return SideEffect;
+    };
+}
+const index_es = withSideEffect;
+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) {
+    if (node.nodeType !== Node.ELEMENT_NODE) return false;
+    var computedStyle = window.getComputedStyle(node, null);
+    if (!computedStyle || !computedStyle.getPropertyValue) return false;
+    return 'none' === computedStyle.getPropertyValue('display') || 'hidden' === computedStyle.getPropertyValue('visibility');
+};
+var getParentNode = function(node) {
+    return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? node.parentNode.host : node.parentNode;
+};
+var isTopNode = function(node) {
+    return node === document || node && node.nodeType === Node.DOCUMENT_NODE;
+};
+var isInert = function(node) {
+    return node.hasAttribute('inert');
+};
+var isVisibleUncached = function(node, checkParent) {
+    return !node || isTopNode(node) || !isElementHidden(node) && !isInert(node) && checkParent(getParentNode(node));
+};
+var isVisibleCached = function(visibilityCache, node) {
+    var cached = visibilityCache.get(node);
+    if (void 0 !== cached) return cached;
+    var result = isVisibleUncached(node, isVisibleCached.bind(void 0, 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 (void 0 !== cached) return cached;
+    var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(void 0, cache));
+    cache.set(node, result);
+    return result;
+};
+var getDataset = function(node) {
+    return node.dataset;
+};
+var isHTMLButtonElement = function(node) {
+    return 'BUTTON' === node.tagName;
+};
+var isHTMLInputElement = function(node) {
+    return 'INPUT' === node.tagName;
+};
+var isRadioElement = function(node) {
+    return isHTMLInputElement(node) && 'radio' === node.type;
+};
+var notHiddenInput = function(node) {
+    return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && ('hidden' === node.type || 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 && (null == (_a = getDataset(node)) ? void 0 : _a.focusGuard));
+};
+var isNotAGuard = function(node) {
+    return !isGuard(node);
+};
+var isDefined = function(x) {
+    return Boolean(x);
+};
+var tabSort = function(a, b) {
+    var aTab = Math.max(0, a.tabIndex);
+    var bTab = Math.max(0, b.tabIndex);
+    var tabDiff = aTab - bTab;
+    var indexDiff = a.index - b.index;
+    if (tabDiff) {
+        if (!aTab) return 1;
+        if (!bTab) return -1;
+    }
+    return tabDiff || indexDiff;
+};
+var getTabIndex = function(node) {
+    if (node.tabIndex < 0) {
+        if (!node.hasAttribute('tabindex')) return 0;
+    }
+    return node.tabIndex;
+};
+var orderByTabIndex = function(nodes, filterNegative, keepGuards) {
+    return toArray(nodes).map(function(node, index) {
+        var tabIndex = getTabIndex(node);
+        return {
+            node: node,
+            index: index,
+            tabIndex: keepGuards && -1 === tabIndex ? (node.dataset || {}).focusGuard ? 0 : -1 : tabIndex
+        };
+    }).filter(function(data) {
+        return !filterNegative || data.tabIndex >= 0;
+    }).sort(tabSort);
+};
+var tabbables = [
+    'button:enabled',
+    'select:enabled',
+    'textarea:enabled',
+    'input:enabled',
+    '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;
+    if (parent instanceof HTMLIFrameElement && (null == (_a = parent.contentDocument) ? 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(focusableWithIframes, parent.parentNode ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function(node) {
+            return node === 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);
+    }, []);
+};
+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 (void 0 === cache) cache = new Map();
+    return toArray(nodes).filter(function(node) {
+        return isAutoFocusAllowedCached(cache, node);
+    });
+};
+var getTabbableNodes = function(topNodes, visibilityCache, withGuards) {
+    return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), true, withGuards);
+};
+var getFocusableNodes = function(topNodes, visibilityCache) {
+    return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), false);
+};
+var parentAutofocusables = function(topNode, visibilityCache) {
+    return filterFocusable(getParentAutofocusables(topNode), visibilityCache);
+};
+var contains = function(scope, element) {
+    if (scope.shadowRoot) return contains(scope.shadowRoot, element);
+    else {
+        if (void 0 !== Object.getPrototypeOf(scope).contains && Object.getPrototypeOf(scope).contains.call(scope, element)) return true;
+        return toArray(scope.children).some(function(child) {
+            var _a;
+            if (child instanceof HTMLIFrameElement) {
+                var iframeBody = null == (_a = child.contentDocument) ? void 0 : _a.body;
+                if (iframeBody) return contains(iframeBody, element);
+                return false;
+            }
+            return contains(child, element);
+        });
+    }
+};
+var safeProbe = function(cb) {
+    try {
+        return cb();
+    } catch (e) {
+        return;
+    }
+};
+var getActiveElement = function(inDocument) {
+    if (void 0 === inDocument) inDocument = document;
+    if (!inDocument || !inDocument.activeElement) return;
+    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 focusIsHidden = function(inDocument) {
+    if (void 0 === inDocument) inDocument = document;
+    var activeElement = getActiveElement(inDocument);
+    if (!activeElement) return false;
+    return toArray(inDocument.querySelectorAll("[".concat(FOCUS_ALLOW, "]"))).some(function(node) {
+        return contains(node, activeElement);
+    });
+};
+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]);
+        if ((position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0) contained.add(j);
+        if ((position & Node.DOCUMENT_POSITION_CONTAINS) > 0) contained.add(i);
+    }
+    return nodes.filter(function(_, index) {
+        return !contained.has(index);
+    });
+};
+var getTopParent = function(node) {
+    return node.parentNode ? getTopParent(node.parentNode) : node;
+};
+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 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);
+    }));
+};
+var focusInside = function(topNode, activeElement) {
+    if (void 0 === activeElement) 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);
+    });
+};
+var focusOn = function(target, focusOptions) {
+    if (!target) return;
+    if ('focus' in target) target.focus(focusOptions);
+    if ('contentWindow' in target && target.contentWindow) target.contentWindow.focus();
+};
+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;
+};
+var correctNodes = function(nodes) {
+    var resultSet = new Set();
+    nodes.forEach(function(node) {
+        return resultSet.add(correctNode(node, nodes));
+    });
+    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, node) {
+    return nodes.indexOf(correctNode(node, nodes));
+};
+var NEW_FOCUS = 'NEW_FOCUS';
+var newFocus = function(innerNodes, innerTabbables, outerNodes, activeElement, lastNode) {
+    var cnt = innerNodes.length;
+    var firstFocus = innerNodes[0];
+    var lastFocus = innerNodes[cnt - 1];
+    var isOnGuard = isGuard(activeElement);
+    if (activeElement && innerNodes.indexOf(activeElement) >= 0) return;
+    var activeIndex = void 0 !== activeElement ? outerNodes.indexOf(activeElement) : -1;
+    var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;
+    var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;
+    if (-1 === activeIndex) {
+        if (-1 !== lastNodeInside) return lastNodeInside;
+        return NEW_FOCUS;
+    }
+    if (-1 === lastNodeInside) return NEW_FOCUS;
+    var indexDiff = activeIndex - lastIndex;
+    var firstNodeIndex = outerNodes.indexOf(firstFocus);
+    var lastNodeIndex = outerNodes.indexOf(lastFocus);
+    var correctedNodes = correctNodes(outerNodes);
+    var currentFocusableIndex = void 0 !== activeElement ? correctedNodes.indexOf(activeElement) : -1;
+    var previousFocusableIndex = lastNode ? correctedNodes.indexOf(lastNode) : currentFocusableIndex;
+    var tabbableNodes = correctedNodes.filter(function(node) {
+        return node.tabIndex >= 0;
+    });
+    var currentTabbableIndex = void 0 !== activeElement ? tabbableNodes.indexOf(activeElement) : -1;
+    var previousTabbableIndex = lastNode ? tabbableNodes.indexOf(lastNode) : currentTabbableIndex;
+    var focusIndexDiff = currentTabbableIndex >= 0 && previousTabbableIndex >= 0 ? previousTabbableIndex - currentTabbableIndex : previousFocusableIndex - currentFocusableIndex;
+    if (!indexDiff && lastNodeInside >= 0) return lastNodeInside;
+    if (0 === innerTabbables.length) return lastNodeInside;
+    var returnFirstNode = pickFocusable(innerNodes, innerTabbables[0]);
+    var returnLastNode = pickFocusable(innerNodes, innerTabbables[innerTabbables.length - 1]);
+    if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) return returnLastNode;
+    if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) return returnFirstNode;
+    if (indexDiff && Math.abs(focusIndexDiff) > 1) return lastNodeInside;
+    if (activeIndex <= firstNodeIndex) return returnLastNode;
+    if (activeIndex > lastNodeIndex) return returnFirstNode;
+    if (indexDiff) {
+        if (Math.abs(indexDiff) > 1) return lastNodeInside;
+        return (cnt + lastNodeInside + indexDiff) % cnt;
+    }
+};
+var findAutoFocused = function(autoFocusables) {
+    return function(node) {
+        var _a;
+        var autofocus = null == (_a = getDataset(node)) ? void 0 : _a.autofocus;
+        return node.autofocus || void 0 !== autofocus && 'false' !== autofocus || 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 (void 0 === parents) parents = [];
+    parents.push(node);
+    if (node.parentNode) getParents(node.parentNode.host || node.parentNode, parents);
+    return parents;
+};
+var getCommonParent = function(nodeA, nodeB) {
+    var parentsA = getParents(nodeA);
+    var parentsB = getParents(nodeB);
+    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) topCommon = !topCommon || contains(common, topCommon) ? common : getCommonParent(common, topCommon);
+        });
+    });
+    return topCommon;
+};
+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();
+    dstNodes.forEach(function(entity) {
+        return remap.set(entity.node, entity);
+    });
+    return srcNodes.map(function(node) {
+        return remap.get(node);
+    }).filter(isDefined);
+};
+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 = anyFocusable.filter(function(_a) {
+        var node = _a.node;
+        return isNotAGuard(node);
+    });
+    if (!innerElements[0]) return;
+    var outerNodes = getFocusableNodes([
+        commonParent
+    ], visibilityCache).map(function(_a) {
+        var node = _a.node;
+        return node;
+    });
+    var orderedInnerElements = reorderNodes(outerNodes, innerElements);
+    var innerFocusables = orderedInnerElements.map(function(_a) {
+        var node = _a.node;
+        return node;
+    });
+    var innerTabbable = orderedInnerElements.filter(function(_a) {
+        var tabIndex = _a.tabIndex;
+        return tabIndex >= 0;
+    }).map(function(_a) {
+        var node = _a.node;
+        return node;
+    });
+    var newId = newFocus(innerFocusables, innerTabbable, outerNodes, activeElement, lastNode);
+    if (newId === NEW_FOCUS) {
+        var focusNode = pickAutofocus(anyFocusable, innerTabbable, allParentAutofocusables(entries, visibilityCache)) || pickAutofocus(anyFocusable, innerFocusables, allParentAutofocusables(entries, visibilityCache));
+        if (focusNode) return {
+            node: focusNode
+        };
+        else return void console.warn('focus-lock: cannot find any node to move focus into');
+    }
+    if (void 0 === newId) return newId;
+    return orderedInnerElements[newId];
+};
+var guardCount = 0;
+var lockDisabled = false;
+var moveFocusInside = function(topNode, lastNode, options) {
+    if (void 0 === options) options = {};
+    var focusable = focusSolver(topNode, lastNode);
+    if (lockDisabled) return;
+    if (focusable) {
+        if (guardCount > 2) {
+            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 weakRef(value) {
+    if (!value) return null;
+    if ("u" < typeof WeakRef) return function() {
+        return value || null;
+    };
+    var w = value ? new WeakRef(value) : null;
+    return function() {
+        return (null == w ? void 0 : w.deref()) || null;
+    };
+}
+var recordElementLocation = function(element) {
+    if (!element) return null;
+    var stack = [];
+    var currentElement = element;
+    while(currentElement && currentElement !== document.body){
+        stack.push({
+            current: weakRef(currentElement),
+            parent: weakRef(currentElement.parentElement),
+            left: weakRef(currentElement.previousElementSibling),
+            right: weakRef(currentElement.nextElementSibling)
+        });
+        currentElement = currentElement.parentElement;
+    }
+    return {
+        element: weakRef(element),
+        stack: stack,
+        ownerDocument: element.ownerDocument
+    };
+};
+var restoreFocusTo = function(location) {
+    var _a, _b, _c, _d, _e;
+    if (!location) return;
+    var stack = location.stack, ownerDocument = location.ownerDocument;
+    var visibilityCache = new Map();
+    for(var _i = 0, stack_1 = stack; _i < stack_1.length; _i++){
+        var line = stack_1[_i];
+        var parent_1 = null == (_a = line.parent) ? void 0 : _a.call(line);
+        if (parent_1 && ownerDocument.contains(parent_1)) {
+            var left = null == (_b = line.left) ? void 0 : _b.call(line);
+            var savedCurrent = line.current();
+            var current = parent_1.contains(savedCurrent) ? savedCurrent : void 0;
+            var right = null == (_c = line.right) ? void 0 : _c.call(line);
+            var focusables = getTabbableNodes([
+                parent_1
+            ], visibilityCache);
+            var aim = null != (_e = null != (_d = null != current ? current : null == left ? void 0 : left.nextElementSibling) ? _d : right) ? _e : left;
+            while(aim){
+                for(var _f = 0, focusables_1 = focusables; _f < focusables_1.length; _f++){
+                    var focusable = focusables_1[_f];
+                    if (null == aim ? void 0 : aim.contains(focusable.node)) return focusable.node;
+                }
+                aim = aim.nextElementSibling;
+            }
+            if (focusables.length) return focusables[0].node;
+        }
+    }
+};
+var return_focus_captureFocusRestore = function(targetElement) {
+    var location = recordElementLocation(targetElement);
+    return function() {
+        return restoreFocusTo(location);
+    };
+};
+var expandFocusableNodes = function(topNode) {
+    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);
+    var commonParent = getTopCommonParent(topNode, topNode, entries);
+    var outerNodes = orderByTabIndex(getFocusables([
+        commonParent
+    ], true), true, true);
+    var innerElements = getFocusables(entries, false);
+    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 getRelativeFocusable = function(element, scope, useTabbables) {
+    if (!element || !scope) {
+        console.error('no element or scope given');
+        return {};
+    }
+    var shards = asArray(scope);
+    if (shards.every(function(shard) {
+        return !contains(shard, element);
+    })) {
+        console.error('Active element is not contained in the scope');
+        return {};
+    }
+    var focusables = useTabbables ? getTabbableNodes(shards, new Map()) : getFocusableNodes(shards, new Map());
+    var current = focusables.findIndex(function(_a) {
+        var node = _a.node;
+        return node === element;
+    });
+    if (-1 === current) return;
+    return {
+        prev: focusables[current - 1],
+        next: focusables[current + 1],
+        first: focusables[0],
+        last: focusables[focusables.length - 1]
+    };
+};
+var getBoundary = function(shards, useTabbables) {
+    var set = useTabbables ? getTabbableNodes(asArray(shards), new Map()) : getFocusableNodes(asArray(shards), new Map());
+    return {
+        first: set[0],
+        last: set[set.length - 1]
+    };
+};
+var defaultOptions = function(options) {
+    return Object.assign({
+        scope: document.body,
+        cycle: true,
+        onlyTabbable: true
+    }, options);
+};
+var moveFocus = function(fromElement, options, cb) {
+    if (void 0 === options) options = {};
+    var newOptions = defaultOptions(options);
+    var solution = getRelativeFocusable(fromElement, newOptions.scope, newOptions.onlyTabbable);
+    if (!solution) return;
+    var target = cb(solution, newOptions.cycle);
+    if (target) focusOn(target.node, newOptions.focusOptions);
+};
+var focusNextElement = function(fromElement, options) {
+    if (void 0 === options) options = {};
+    moveFocus(fromElement, options, function(_a, cycle) {
+        var next = _a.next, first = _a.first;
+        return next || cycle && first;
+    });
+};
+var focusPrevElement = function(fromElement, options) {
+    if (void 0 === options) options = {};
+    moveFocus(fromElement, options, function(_a, cycle) {
+        var prev = _a.prev, last = _a.last;
+        return prev || cycle && last;
+    });
+};
+var pickBoundary = function(scope, options, what) {
+    var _a;
+    var boundary = getBoundary(scope, null != (_a = options.onlyTabbable) ? _a : true);
+    var node = boundary[what];
+    if (node) focusOn(node.node, options.focusOptions);
+};
+var focusFirstElement = function(scope, options) {
+    if (void 0 === options) options = {};
+    pickBoundary(scope, options, 'first');
+};
+var focusLastElement = function(scope, options) {
+    if (void 0 === options) options = {};
+    pickBoundary(scope, options, 'last');
+};
+function deferAction(action) {
+    setTimeout(action, 1);
+}
+var util_extractRef = function(ref) {
+    return ref && 'current' in ref ? ref.current : ref;
+};
+var Trap_focusOnBody = function() {
+    return document && document.activeElement === document.body;
+};
+var Trap_isFreeFocus = function() {
+    return Trap_focusOnBody() || focusIsHidden();
+};
+var lastActiveTrap = null;
+var lastActiveFocus = null;
+var Trap_tryRestoreFocus = function() {
+    return null;
+};
+var lastPortaledElement = null;
+var focusWasOutsideWindow = false;
+var windowFocused = false;
+var Trap_defaultWhitelist = function() {
+    return true;
+};
+var Trap_focusWhitelisted = function(activeElement) {
+    return (lastActiveTrap.whiteList || Trap_defaultWhitelist)(activeElement);
+};
+var Trap_recordPortal = function(observerNode, portaledElement) {
+    lastPortaledElement = {
+        observerNode: observerNode,
+        portaledElement: portaledElement
+    };
+};
+var Trap_focusIsPortaledPair = function(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) return;
+            lastGuard = null;
+        } else break;
+    }while ((i += step) !== end)
+    if (lastGuard) lastGuard.node.tabIndex = 0;
+}
+var Trap_focusWasOutside = function(crossFrameOption) {
+    if (crossFrameOption) return Boolean(focusWasOutsideWindow);
+    return 'meanwhile' === focusWasOutsideWindow;
+};
+var Trap_checkInHost = function checkInHost(check, el, boundary) {
+    return el && (el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) || el.parentNode && checkInHost(check, el.parentNode, boundary));
+};
+var Trap_withinHost = function(activeElement, workingArea) {
+    return workingArea.some(function(area) {
+        return Trap_checkInHost(activeElement, area, area);
+    });
+};
+var Trap_getNodeFocusables = function(nodes) {
+    return getFocusableNodes(nodes, new Map());
+};
+var Trap_isNotFocusable = function(node) {
+    return !Trap_getNodeFocusables([
+        node.parentNode
+    ]).some(function(el) {
+        return el.node === node;
+    });
+};
+var Trap_activateTrap = function() {
+    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, noFocusGuards = _lastActiveTrap.noFocusGuards;
+        var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;
+        if (Trap_focusOnBody() && lastActiveFocus && lastActiveFocus !== document.body) {
+            if (!document.body.contains(lastActiveFocus) || Trap_isNotFocusable(lastActiveFocus)) {
+                var newTarget = Trap_tryRestoreFocus();
+                if (newTarget) newTarget.focus();
+            }
+        }
+        var activeElement = document && document.activeElement;
+        if (workingNode) {
+            var workingArea = [
+                workingNode
+            ].concat(shards.map(util_extractRef).filter(Boolean));
+            var shouldForceRestoreFocus = function() {
+                if (!Trap_focusWasOutside(crossFrame) || !noFocusGuards || !lastActiveFocus || windowFocused) return false;
+                var nodes = Trap_getNodeFocusables(workingArea);
+                var lastIndex = nodes.findIndex(function(_ref) {
+                    var node = _ref.node;
+                    return node === lastActiveFocus;
+                });
+                return 0 === lastIndex || lastIndex === nodes.length - 1;
+            };
+            if (!activeElement || Trap_focusWhitelisted(activeElement)) {
+                if (persistentFocus || shouldForceRestoreFocus() || !Trap_isFreeFocus() || !lastActiveFocus && autoFocus) {
+                    if (workingNode && !(focusInside(workingArea) || activeElement && Trap_withinHost(activeElement, workingArea) || Trap_focusIsPortaledPair(activeElement))) if (document && !lastActiveFocus && activeElement && !autoFocus) {
+                        if (activeElement.blur) activeElement.blur();
+                        document.body.focus();
+                    } else {
+                        result = moveFocusInside(workingArea, lastActiveFocus, {
+                            focusOptions: focusOptions
+                        });
+                        lastPortaledElement = {};
+                    }
+                    lastActiveFocus = document && document.activeElement;
+                    if (lastActiveFocus !== document.body) Trap_tryRestoreFocus = return_focus_captureFocusRestore(lastActiveFocus);
+                    focusWasOutsideWindow = false;
+                }
+            }
+            if (document && activeElement !== document.activeElement && document.querySelector('[data-focus-auto-guard]')) {
+                var newActiveElement = document && document.activeElement;
+                var allNodes = expandFocusableNodes(workingArea);
+                var focusedIndex = allNodes.map(function(_ref2) {
+                    var node = _ref2.node;
+                    return node;
+                }).indexOf(newActiveElement);
+                if (focusedIndex > -1) {
+                    allNodes.filter(function(_ref3) {
+                        var guard = _ref3.guard, node = _ref3.node;
+                        return guard && node.dataset.focusAutoGuard;
+                    }).forEach(function(_ref4) {
+                        var node = _ref4.node;
+                        return node.removeAttribute('tabIndex');
+                    });
+                    autoGuard(focusedIndex, allNodes.length, 1, allNodes);
+                    autoGuard(focusedIndex, -1, -1, allNodes);
+                }
+            }
+        }
+    }
+    return result;
+};
+var Trap_onTrap = function(event) {
+    if (Trap_activateTrap() && event) {
+        event.stopPropagation();
+        event.preventDefault();
+    }
+};
+var Trap_onBlur = function() {
+    return deferAction(Trap_activateTrap);
+};
+var Trap_onFocus = function(event) {
+    var source = event.target;
+    var currentNode = event.currentTarget;
+    if (!currentNode.contains(source)) Trap_recordPortal(currentNode, source);
+};
+var Trap_FocusWatcher = function() {
+    return null;
+};
+var Trap_FocusTrap = function(_ref5) {
+    var children = _ref5.children;
+    return /*#__PURE__*/ react.createElement("div", {
+        onBlur: Trap_onBlur,
+        onFocus: Trap_onFocus
+    }, children);
+};
+Trap_FocusTrap.propTypes = "production" !== process.env.NODE_ENV ? {
+    children: prop_types_default().node.isRequired
+} : {};
+var Trap_onWindowFocus = function() {
+    windowFocused = true;
+};
+var Trap_onWindowBlur = function() {
+    windowFocused = false;
+    focusWasOutsideWindow = 'just';
+    deferAction(function() {
+        focusWasOutsideWindow = 'meanwhile';
+    });
+};
+var Trap_attachHandler = function() {
+    document.addEventListener('focusin', Trap_onTrap);
+    document.addEventListener('focusout', Trap_onBlur);
+    window.addEventListener('focus', Trap_onWindowFocus);
+    window.addEventListener('blur', Trap_onWindowBlur);
+};
+var Trap_detachHandler = function() {
+    document.removeEventListener('focusin', Trap_onTrap);
+    document.removeEventListener('focusout', Trap_onBlur);
+    window.removeEventListener('focus', Trap_onWindowFocus);
+    window.removeEventListener('blur', Trap_onWindowBlur);
+};
+function Trap_reducePropsToState(propsList) {
+    return propsList.filter(function(_ref6) {
+        var disabled = _ref6.disabled;
+        return !disabled;
+    });
+}
+var focusLockAPI = {
+    moveFocusInside: moveFocusInside,
+    focusInside: focusInside,
+    focusNextElement: focusNextElement,
+    focusPrevElement: focusPrevElement,
+    focusFirstElement: focusFirstElement,
+    focusLastElement: focusLastElement,
+    captureFocusRestore: return_focus_captureFocusRestore
+};
+function Trap_handleStateChangeOnClient(traps) {
+    var trap = traps.slice(-1)[0];
+    if (trap && !lastActiveTrap) Trap_attachHandler();
+    var lastTrap = lastActiveTrap;
+    var sameTrap = lastTrap && trap && trap.id === lastTrap.id;
+    lastActiveTrap = trap;
+    if (lastTrap && !sameTrap) {
+        lastTrap.onDeactivation();
+        if (!traps.filter(function(_ref7) {
+            var id = _ref7.id;
+            return id === lastTrap.id;
+        }).length) lastTrap.returnFocus(!trap);
+    }
+    if (trap) {
+        lastActiveFocus = null;
+        if (!sameTrap || lastTrap.observed !== trap.observed) trap.onActivation(focusLockAPI);
+        Trap_activateTrap();
+        deferAction(Trap_activateTrap);
+    } else {
+        Trap_detachHandler();
+        lastActiveFocus = null;
+    }
+}
+mediumFocus.assignSyncMedium(Trap_onFocus);
+mediumBlur.assignMedium(Trap_onBlur);
+mediumEffect.assignMedium(function(cb) {
+    return cb(focusLockAPI);
+});
+const Trap = index_es(Trap_reducePropsToState, Trap_handleStateChangeOnClient)(Trap_FocusWatcher);
+var FocusLockCombination = /*#__PURE__*/ forwardRef(function(props, ref) {
+    return /*#__PURE__*/ react.createElement(Lock, _extends({
+        sideCar: Trap,
+        ref: ref
+    }, props));
+});
+var Combination_ref = Lock.propTypes || {}, propTypes = (Combination_ref.sideCar, _objectWithoutPropertiesLoose(Combination_ref, [
+    "sideCar"
+]));
+FocusLockCombination.propTypes = "production" !== process.env.NODE_ENV ? propTypes : {};
+const Combination = FocusLockCombination;
+const es2015 = Combination;
+const scrollLocks = new WeakMap();
+function lockBodyScroll(body) {
+    const existing = scrollLocks.get(body);
+    const lock = existing ?? {
+        owners: new Set(),
+        styles: [
+            'overflow-x',
+            'overflow-y',
+            'padding-right'
+        ].map((property)=>({
+                property,
+                value: body.style.getPropertyValue(property),
+                priority: body.style.getPropertyPriority(property)
+            }))
+    };
+    if (!existing) {
+        scrollLocks.set(body, lock);
+        if ('hidden' !== body.style.overflowY && 'hidden' !== body.style.overflow) {
+            const doc = body.ownerDocument;
+            const view = doc.defaultView;
+            const scrollbar = (view?.innerWidth ?? 0) - doc.documentElement.clientWidth;
+            if (view && scrollbar > 0) {
+                const padding = Number.parseFloat(view.getComputedStyle(body).paddingRight) || 0;
+                body.style.setProperty('padding-right', `${padding + scrollbar}px`, body.style.getPropertyPriority('padding-right'));
+            }
+        }
+        for (const property of [
+            'overflow-x',
+            'overflow-y'
+        ])body.style.setProperty(property, 'hidden', body.style.getPropertyPriority(property));
+    }
+    const owner = Symbol();
+    lock.owners.add(owner);
+    return ()=>{
+        if (!lock.owners.delete(owner) || lock.owners.size > 0) return;
+        scrollLocks.delete(body);
+        for (const { property, value, priority } of lock.styles)body.style.setProperty(property, value, priority);
+    };
+}
+const ENTER = 'ov-drawer--enter';
+const ENTER_ACTIVE = 'ov-drawer--enter-active';
+const MOTION = {
+    appear: ENTER,
+    appearActive: ENTER_ACTIVE,
+    enter: ENTER,
+    enterActive: ENTER_ACTIVE,
+    exitActive: 'ov-drawer--exit'
+};
+function Drawer({ id, open, title, closeLabel, triggerRef, children, className, lang, onClose }) {
+    const panelRef = useRef(null);
+    const maskRef = useRef(null);
+    const [present, setPresent] = useState(open);
+    const [layer, setLayer] = useState(null);
+    usePortalTheme(Boolean(layer), triggerRef, layer);
+    useEffect(()=>{
+        if (layer) return lockBodyScroll(layer.ownerDocument.body);
+    }, [
+        layer
+    ]);
+    if ("u" < typeof document || !open && !present) return null;
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ jsxs("div", {
+        ref: setLayer,
+        role: "presentation",
+        className: [
+            'ov-drawer',
+            className
+        ].filter(Boolean).join(' '),
+        lang: lang,
+        onKeyDown: (event)=>{
+            if ('Escape' !== event.key || event.defaultPrevented) return;
+            if (!(event.target instanceof Node) || !event.currentTarget.contains(event.target)) return;
+            event.preventDefault();
+            event.stopPropagation();
+            onClose();
+        },
+        children: [
+            /*#__PURE__*/ jsx(CSSTransition, {
+                nodeRef: maskRef,
+                in: open,
+                timeout: 300,
+                classNames: MOTION,
+                appear: true,
+                mountOnEnter: true,
+                unmountOnExit: true,
+                children: /*#__PURE__*/ jsx("button", {
+                    ref: maskRef,
+                    type: "button",
+                    className: "ov-drawer__mask",
+                    "aria-label": closeLabel,
+                    "aria-hidden": "true",
+                    tabIndex: -1,
+                    onClick: onClose
+                })
+            }),
+            /*#__PURE__*/ jsx(CSSTransition, {
+                nodeRef: panelRef,
+                in: open,
+                timeout: 300,
+                classNames: MOTION,
+                appear: true,
+                mountOnEnter: true,
+                unmountOnExit: true,
+                onEnter: ()=>setPresent(true),
+                onExited: ()=>setPresent(false),
+                children: /*#__PURE__*/ jsx("div", {
+                    ref: panelRef,
+                    id: id,
+                    role: "dialog",
+                    "aria-modal": "true",
+                    "aria-label": title,
+                    className: "ov-drawer__panel",
+                    children: /*#__PURE__*/ jsxs(es2015, {
+                        className: "ov-drawer__focus-lock",
+                        returnFocus: {
+                            preventScroll: true
+                        },
+                        crossFrame: false,
+                        children: [
+                            /*#__PURE__*/ jsx("button", {
+                                type: "button",
+                                className: "ov-drawer__close",
+                                "aria-label": closeLabel,
+                                onClick: onClose,
+                                children: /*#__PURE__*/ jsx(removereact, {
+                                    width: 16,
+                                    height: 16,
+                                    "aria-hidden": "true"
+                                })
+                            }),
+                            /*#__PURE__*/ jsx("div", {
+                                className: "ov-drawer__body",
+                                children: children
+                            })
+                        ]
+                    })
+                })
+            })
+        ]
+    }), document.body);
+}
+function ConnectAgentIcon() {
+    return /*#__PURE__*/ jsx("svg", {
+        width: "14",
+        height: "14",
+        viewBox: "0 0 14 14",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "1.4",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        "aria-hidden": "true",
+        focusable: "false",
+        children: /*#__PURE__*/ jsx("path", {
+            d: "M5.187 1.75V3.736M8.876 1.75V3.736M7.031 10.547V12.25M4.052 3.736H10.011A1.135 1.135 0 0 1 11.147 4.872V8.277A2.27 2.27 0 0 1 8.876 10.547H5.187A2.27 2.27 0 0 1 2.917 8.277V4.872A1.135 1.135 0 0 1 4.052 3.736Z"
+        })
+    });
+}
+function ImportResourcesIcon() {
+    return /*#__PURE__*/ jsx("svg", {
+        width: "12",
+        height: "12",
+        viewBox: "0 0 12 12",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "1.4",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        "aria-hidden": "true",
+        focusable: "false",
+        children: /*#__PURE__*/ jsx("path", {
+            d: "M10.5 7.5V8.1C10.5 8.94008 10.5 9.36012 10.3365 9.68099C10.1927 9.96323 9.96323 10.1927 9.68099 10.3365C9.36012 10.5 8.94008 10.5 8.1 10.5H3.9C3.05992 10.5 2.63988 10.5 2.31901 10.3365C2.03677 10.1927 1.8073 9.96323 1.66349 9.68099C1.5 9.36012 1.5 8.94008 1.5 8.1V7.5M3.5 4L6 1.5L8.5 4M6 1.5V7.5"
+        })
+    });
+}
+function FileBrowserEntries({ locale = 'en-US', agentConnect, onConnectAgent, onImportResources, renderImportResources, labels, className, ...rest }) {
+    const triggerRef = useRef(null);
+    const drawerId = useId();
+    const [drawerOpen, setDrawerOpen] = useState(false);
+    const text = resolveFileBrowserEntriesLabels(locale, labels);
+    const showConnect = Boolean(agentConnect || onConnectAgent);
+    const importButton = /*#__PURE__*/ jsxs("button", {
+        type: "button",
+        className: "ov-file-browser-entries__entry",
+        onClick: onImportResources,
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "ov-file-browser-entries__icon",
+                "aria-hidden": "true",
+                children: /*#__PURE__*/ jsx(ImportResourcesIcon, {})
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "ov-file-browser-entries__label",
+                children: text.importResources
+            })
+        ]
+    });
+    const importEntry = renderImportResources ? renderImportResources(importButton) : onImportResources ? importButton : null;
+    const showImport = null != importEntry && 'boolean' != typeof importEntry;
+    if (!showConnect && !showImport) return null;
+    return /*#__PURE__*/ jsxs("div", {
+        ...rest,
+        className: [
+            'ov-file-browser-entries',
+            className
+        ].filter(Boolean).join(' '),
+        children: [
+            showConnect ? /*#__PURE__*/ jsxs("button", {
+                ref: triggerRef,
+                type: "button",
+                className: "ov-file-browser-entries__entry",
+                "aria-haspopup": agentConnect ? 'dialog' : void 0,
+                "aria-controls": agentConnect ? drawerId : void 0,
+                "aria-expanded": agentConnect ? drawerOpen : void 0,
+                onClick: ()=>{
+                    if (agentConnect) setDrawerOpen(true);
+                    onConnectAgent?.();
+                },
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-browser-entries__icon",
+                        "aria-hidden": "true",
+                        children: /*#__PURE__*/ jsx(ConnectAgentIcon, {})
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-browser-entries__label",
+                        children: text.connectAgent
+                    })
+                ]
+            }) : null,
+            showConnect && showImport ? /*#__PURE__*/ jsx(Divider, {
+                className: "ov-file-browser-entries__divider",
+                length: 12,
+                color: "var(--ov-ui-color-primary, var(--ov-ui-primary-default))",
+                style: {
+                    opacity: 0.5
+                }
+            }) : null,
+            agentConnect ? /*#__PURE__*/ jsx(Drawer, {
+                id: drawerId,
+                open: drawerOpen,
+                title: text.connectAgent,
+                closeLabel: text.close,
+                triggerRef: triggerRef,
+                className: "ov-file-browser-entries__drawer",
+                lang: agentConnect.locale,
+                onClose: ()=>setDrawerOpen(false),
+                children: /*#__PURE__*/ jsx(AgentConnect, {
+                    ...agentConnect
+                })
+            }) : null,
+            showImport ? /*#__PURE__*/ jsx("span", {
+                className: "ov-file-browser-entries__import-slot",
+                children: importEntry
+            }) : null
+        ]
+    });
+}
+export { FileBrowserEntries };