mui-drawer 1.0.0

package/dist/mui-drawer.es.js

@@ -0,0 +1,2079 @@
+!function(){"use strict";try{if("undefined"!=typeof document){var r=document.createElement("style");r.appendChild(document.createTextNode(".vi-drawer .MuiDrawer-paper{overflow-y:hidden;max-width:100%}.vi-drawer .drawer-body-pt{padding-top:0}.vi-drawer .drawer-body-pb{padding-bottom:0}.vi-drawer .close-icon{cursor:pointer;color:#717371}.vi-drawer .vi-drawer-actions{position:sticky;bottom:0;padding:24px;background-color:#fff;z-index:50;display:flex;align-items:center;justify-content:flex-end}.vi-drawer .vi-drawer-actions .vi-drawer-action-ctas{display:flex;align-items:center;justify-content:flex-end;gap:16px}.vi-drawer .vi-drawer-actions .vi-drawer-cta{width:50%;align-self:flex-end}.vi-drawer .vi-drawer-actions .vi-drawer-cta.destructive{background-color:#ed1d31}.vi-drawer .vi-drawer-actions.tertiary-cta{justify-content:space-between;gap:16px}.vi-drawer .vi-drawer-actions.tertiary-cta .tertiary-cta-destructive{color:#ed1d31}.vi-drawer .vi-drawer-actions.divider{border-top:1px solid #e9e9e9}.vi-drawer .vi-drawer-title{position:sticky;top:0;padding:24px 24px 28px;background-color:#fff;z-index:50}.vi-drawer .vi-drawer-title .description{margin-top:16px!important}.vi-drawer .drawer-children{padding:24px;overflow-y:auto;height:100%}.vi-drawer .drawer-children.with-header-footer{padding-top:0;padding-bottom:28px;height:calc(100% - 173px)}.vi-drawer .drawer-children.with-header{padding-top:0;height:calc(100% - 80px)}.vi-drawer .drawer-children.with-footer{padding-bottom:28px;height:calc(100% - 93px)}.vi-drawer .drawer-children.no-divider{padding-bottom:0}@media only screen and (max-width: 600px){.vi-drawer .MuiPaper-root{margin:0;width:100%;height:100%}.vi-drawer .vi-drawer-actions-wrapper,.vi-drawer .vi-drawer-actions{flex-direction:column-reverse;gap:12px}.vi-drawer .vi-drawer-actions .vi-drawer-action-ctas{flex-direction:column-reverse;width:100%!important;gap:12px}.vi-drawer .vi-drawer-actions .vi-drawer-cta{width:100%}.vi-drawer .drawer-children.one-cta.with-header-footer{height:calc(100% - 170px)}.vi-drawer .drawer-children.one-cta.with-header{height:calc(100% - 80px)}.vi-drawer .drawer-children.one-cta.with-footer{height:calc(100% - 90px)}.vi-drawer .drawer-children.two-ctas.with-header-footer{height:calc(100% - 222px)}.vi-drawer .drawer-children.two-ctas.with-header{height:calc(100% - 80px)}.vi-drawer .drawer-children.two-ctas.with-footer{height:calc(100% - 142px)}.vi-drawer .drawer-children.three-ctas.with-header-footer{height:calc(100% - 259px)}.vi-drawer .drawer-children.three-ctas.with-header{height:calc(100% - 80px)}.vi-drawer .drawer-children.three-ctas.with-footer{height:calc(100% - 179px)}}")),document.head.appendChild(r)}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}}();
+import { jsx, jsxs } from 'react/jsx-runtime';
+import * as React from 'react';
+import { useState, useRef, useEffect } from 'react';
+import { createTheme, Drawer, Typography, Tooltip } from '@mui/material';
+import { createSvgIcon } from '@mui/material/utils';
+import { useTheme, ThemeProvider } from '@mui/material/styles';
+import Button from '@mui/material/Button';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var classnames = {exports: {}};
+
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+
+var hasRequiredClassnames;
+
+function requireClassnames () {
+	if (hasRequiredClassnames) return classnames.exports;
+	hasRequiredClassnames = 1;
+	(function (module) {
+		/* global define */
+
+		(function () {
+
+			var hasOwn = {}.hasOwnProperty;
+
+			function classNames () {
+				var classes = '';
+
+				for (var i = 0; i < arguments.length; i++) {
+					var arg = arguments[i];
+					if (arg) {
+						classes = appendClass(classes, parseValue(arg));
+					}
+				}
+
+				return classes;
+			}
+
+			function parseValue (arg) {
+				if (typeof arg === 'string' || typeof arg === 'number') {
+					return arg;
+				}
+
+				if (typeof arg !== 'object') {
+					return '';
+				}
+
+				if (Array.isArray(arg)) {
+					return classNames.apply(null, arg);
+				}
+
+				if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+					return arg.toString();
+				}
+
+				var classes = '';
+
+				for (var key in arg) {
+					if (hasOwn.call(arg, key) && arg[key]) {
+						classes = appendClass(classes, key);
+					}
+				}
+
+				return classes;
+			}
+
+			function appendClass (value, newClass) {
+				if (!newClass) {
+					return value;
+				}
+			
+				if (value) {
+					return value + ' ' + newClass;
+				}
+			
+				return value + newClass;
+			}
+
+			if (module.exports) {
+				classNames.default = classNames;
+				module.exports = classNames;
+			} else {
+				window.classNames = classNames;
+			}
+		}()); 
+	} (classnames));
+	return classnames.exports;
+}
+
+var classnamesExports = requireClassnames();
+const classNames = /*@__PURE__*/getDefaultExportFromCjs(classnamesExports);
+
+const CloseIcon = createSvgIcon(/*#__PURE__*/jsx("path", {
+  d: "M19 6.41 17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"
+}), 'Close');
+
+let warnedOnce = false;
+const warn = () => {
+  if (!warnedOnce) {
+    console.warn(['MUI: The LoadingButton component functionality is now part of the Button component from Material UI.', '', "You should use `import Button from '@mui/material/Button'`", "or `import { Button } from '@mui/material'`"].join('\n'));
+    warnedOnce = true;
+  }
+};
+
+/**
+ * @ignore - do not document.
+ */
+const LoadingButton = /*#__PURE__*/React.forwardRef(function DeprecatedLoadingButton(props, ref) {
+  warn();
+  return /*#__PURE__*/jsx(Button, {
+    ref: ref,
+    ...props
+  });
+});
+
+/**
+ * This method returns `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Util
+ * @example
+ *
+ * _.times(2, _.noop);
+ * // => [undefined, undefined]
+ */
+
+var noop_1;
+var hasRequiredNoop;
+
+function requireNoop () {
+	if (hasRequiredNoop) return noop_1;
+	hasRequiredNoop = 1;
+	function noop() {
+	  // No operation performed.
+	}
+
+	noop_1 = noop;
+	return noop_1;
+}
+
+var noopExports = requireNoop();
+const _noop = /*@__PURE__*/getDefaultExportFromCjs(noopExports);
+
+/** Used for built-in method references. */
+
+var _isPrototype;
+var hasRequired_isPrototype;
+
+function require_isPrototype () {
+	if (hasRequired_isPrototype) return _isPrototype;
+	hasRequired_isPrototype = 1;
+	var objectProto = Object.prototype;
+
+	/**
+	 * Checks if `value` is likely a prototype object.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+	 */
+	function isPrototype(value) {
+	  var Ctor = value && value.constructor,
+	      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+	  return value === proto;
+	}
+
+	_isPrototype = isPrototype;
+	return _isPrototype;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+
+var _overArg;
+var hasRequired_overArg;
+
+function require_overArg () {
+	if (hasRequired_overArg) return _overArg;
+	hasRequired_overArg = 1;
+	function overArg(func, transform) {
+	  return function(arg) {
+	    return func(transform(arg));
+	  };
+	}
+
+	_overArg = overArg;
+	return _overArg;
+}
+
+var _nativeKeys;
+var hasRequired_nativeKeys;
+
+function require_nativeKeys () {
+	if (hasRequired_nativeKeys) return _nativeKeys;
+	hasRequired_nativeKeys = 1;
+	var overArg = require_overArg();
+
+	/* Built-in method references for those with the same name as other `lodash` methods. */
+	var nativeKeys = overArg(Object.keys, Object);
+
+	_nativeKeys = nativeKeys;
+	return _nativeKeys;
+}
+
+var _baseKeys;
+var hasRequired_baseKeys;
+
+function require_baseKeys () {
+	if (hasRequired_baseKeys) return _baseKeys;
+	hasRequired_baseKeys = 1;
+	var isPrototype = require_isPrototype(),
+	    nativeKeys = require_nativeKeys();
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/**
+	 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function baseKeys(object) {
+	  if (!isPrototype(object)) {
+	    return nativeKeys(object);
+	  }
+	  var result = [];
+	  for (var key in Object(object)) {
+	    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	_baseKeys = baseKeys;
+	return _baseKeys;
+}
+
+/** Detect free variable `global` from Node.js. */
+
+var _freeGlobal;
+var hasRequired_freeGlobal;
+
+function require_freeGlobal () {
+	if (hasRequired_freeGlobal) return _freeGlobal;
+	hasRequired_freeGlobal = 1;
+	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+	_freeGlobal = freeGlobal;
+	return _freeGlobal;
+}
+
+var _root;
+var hasRequired_root;
+
+function require_root () {
+	if (hasRequired_root) return _root;
+	hasRequired_root = 1;
+	var freeGlobal = require_freeGlobal();
+
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function('return this')();
+
+	_root = root;
+	return _root;
+}
+
+var _Symbol;
+var hasRequired_Symbol;
+
+function require_Symbol () {
+	if (hasRequired_Symbol) return _Symbol;
+	hasRequired_Symbol = 1;
+	var root = require_root();
+
+	/** Built-in value references. */
+	var Symbol = root.Symbol;
+
+	_Symbol = Symbol;
+	return _Symbol;
+}
+
+var _getRawTag;
+var hasRequired_getRawTag;
+
+function require_getRawTag () {
+	if (hasRequired_getRawTag) return _getRawTag;
+	hasRequired_getRawTag = 1;
+	var Symbol = require_Symbol();
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var nativeObjectToString = objectProto.toString;
+
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+	/**
+	 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the raw `toStringTag`.
+	 */
+	function getRawTag(value) {
+	  var isOwn = hasOwnProperty.call(value, symToStringTag),
+	      tag = value[symToStringTag];
+
+	  try {
+	    value[symToStringTag] = undefined;
+	    var unmasked = true;
+	  } catch (e) {}
+
+	  var result = nativeObjectToString.call(value);
+	  if (unmasked) {
+	    if (isOwn) {
+	      value[symToStringTag] = tag;
+	    } else {
+	      delete value[symToStringTag];
+	    }
+	  }
+	  return result;
+	}
+
+	_getRawTag = getRawTag;
+	return _getRawTag;
+}
+
+/** Used for built-in method references. */
+
+var _objectToString;
+var hasRequired_objectToString;
+
+function require_objectToString () {
+	if (hasRequired_objectToString) return _objectToString;
+	hasRequired_objectToString = 1;
+	var objectProto = Object.prototype;
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var nativeObjectToString = objectProto.toString;
+
+	/**
+	 * Converts `value` to a string using `Object.prototype.toString`.
+	 *
+	 * @private
+	 * @param {*} value The value to convert.
+	 * @returns {string} Returns the converted string.
+	 */
+	function objectToString(value) {
+	  return nativeObjectToString.call(value);
+	}
+
+	_objectToString = objectToString;
+	return _objectToString;
+}
+
+var _baseGetTag;
+var hasRequired_baseGetTag;
+
+function require_baseGetTag () {
+	if (hasRequired_baseGetTag) return _baseGetTag;
+	hasRequired_baseGetTag = 1;
+	var Symbol = require_Symbol(),
+	    getRawTag = require_getRawTag(),
+	    objectToString = require_objectToString();
+
+	/** `Object#toString` result references. */
+	var nullTag = '[object Null]',
+	    undefinedTag = '[object Undefined]';
+
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+	/**
+	 * The base implementation of `getTag` without fallbacks for buggy environments.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	function baseGetTag(value) {
+	  if (value == null) {
+	    return value === undefined ? undefinedTag : nullTag;
+	  }
+	  return (symToStringTag && symToStringTag in Object(value))
+	    ? getRawTag(value)
+	    : objectToString(value);
+	}
+
+	_baseGetTag = baseGetTag;
+	return _baseGetTag;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+
+var isObject_1;
+var hasRequiredIsObject;
+
+function requireIsObject () {
+	if (hasRequiredIsObject) return isObject_1;
+	hasRequiredIsObject = 1;
+	function isObject(value) {
+	  var type = typeof value;
+	  return value != null && (type == 'object' || type == 'function');
+	}
+
+	isObject_1 = isObject;
+	return isObject_1;
+}
+
+var isFunction_1;
+var hasRequiredIsFunction;
+
+function requireIsFunction () {
+	if (hasRequiredIsFunction) return isFunction_1;
+	hasRequiredIsFunction = 1;
+	var baseGetTag = require_baseGetTag(),
+	    isObject = requireIsObject();
+
+	/** `Object#toString` result references. */
+	var asyncTag = '[object AsyncFunction]',
+	    funcTag = '[object Function]',
+	    genTag = '[object GeneratorFunction]',
+	    proxyTag = '[object Proxy]';
+
+	/**
+	 * Checks if `value` is classified as a `Function` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	 * @example
+	 *
+	 * _.isFunction(_);
+	 * // => true
+	 *
+	 * _.isFunction(/abc/);
+	 * // => false
+	 */
+	function isFunction(value) {
+	  if (!isObject(value)) {
+	    return false;
+	  }
+	  // The use of `Object#toString` avoids issues with the `typeof` operator
+	  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+	  var tag = baseGetTag(value);
+	  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+	}
+
+	isFunction_1 = isFunction;
+	return isFunction_1;
+}
+
+var _coreJsData;
+var hasRequired_coreJsData;
+
+function require_coreJsData () {
+	if (hasRequired_coreJsData) return _coreJsData;
+	hasRequired_coreJsData = 1;
+	var root = require_root();
+
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = root['__core-js_shared__'];
+
+	_coreJsData = coreJsData;
+	return _coreJsData;
+}
+
+var _isMasked;
+var hasRequired_isMasked;
+
+function require_isMasked () {
+	if (hasRequired_isMasked) return _isMasked;
+	hasRequired_isMasked = 1;
+	var coreJsData = require_coreJsData();
+
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = (function() {
+	  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+	  return uid ? ('Symbol(src)_1.' + uid) : '';
+	}());
+
+	/**
+	 * Checks if `func` has its source masked.
+	 *
+	 * @private
+	 * @param {Function} func The function to check.
+	 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	 */
+	function isMasked(func) {
+	  return !!maskSrcKey && (maskSrcKey in func);
+	}
+
+	_isMasked = isMasked;
+	return _isMasked;
+}
+
+/** Used for built-in method references. */
+
+var _toSource;
+var hasRequired_toSource;
+
+function require_toSource () {
+	if (hasRequired_toSource) return _toSource;
+	hasRequired_toSource = 1;
+	var funcProto = Function.prototype;
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/**
+	 * Converts `func` to its source code.
+	 *
+	 * @private
+	 * @param {Function} func The function to convert.
+	 * @returns {string} Returns the source code.
+	 */
+	function toSource(func) {
+	  if (func != null) {
+	    try {
+	      return funcToString.call(func);
+	    } catch (e) {}
+	    try {
+	      return (func + '');
+	    } catch (e) {}
+	  }
+	  return '';
+	}
+
+	_toSource = toSource;
+	return _toSource;
+}
+
+var _baseIsNative;
+var hasRequired_baseIsNative;
+
+function require_baseIsNative () {
+	if (hasRequired_baseIsNative) return _baseIsNative;
+	hasRequired_baseIsNative = 1;
+	var isFunction = requireIsFunction(),
+	    isMasked = require_isMasked(),
+	    isObject = requireIsObject(),
+	    toSource = require_toSource();
+
+	/**
+	 * Used to match `RegExp`
+	 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	 */
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+	/** Used for built-in method references. */
+	var funcProto = Function.prototype,
+	    objectProto = Object.prototype;
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp('^' +
+	  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+	);
+
+	/**
+	 * The base implementation of `_.isNative` without bad shim checks.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a native function,
+	 *  else `false`.
+	 */
+	function baseIsNative(value) {
+	  if (!isObject(value) || isMasked(value)) {
+	    return false;
+	  }
+	  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+	  return pattern.test(toSource(value));
+	}
+
+	_baseIsNative = baseIsNative;
+	return _baseIsNative;
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+
+var _getValue;
+var hasRequired_getValue;
+
+function require_getValue () {
+	if (hasRequired_getValue) return _getValue;
+	hasRequired_getValue = 1;
+	function getValue(object, key) {
+	  return object == null ? undefined : object[key];
+	}
+
+	_getValue = getValue;
+	return _getValue;
+}
+
+var _getNative;
+var hasRequired_getNative;
+
+function require_getNative () {
+	if (hasRequired_getNative) return _getNative;
+	hasRequired_getNative = 1;
+	var baseIsNative = require_baseIsNative(),
+	    getValue = require_getValue();
+
+	/**
+	 * Gets the native function at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {string} key The key of the method to get.
+	 * @returns {*} Returns the function if it's native, else `undefined`.
+	 */
+	function getNative(object, key) {
+	  var value = getValue(object, key);
+	  return baseIsNative(value) ? value : undefined;
+	}
+
+	_getNative = getNative;
+	return _getNative;
+}
+
+var _DataView;
+var hasRequired_DataView;
+
+function require_DataView () {
+	if (hasRequired_DataView) return _DataView;
+	hasRequired_DataView = 1;
+	var getNative = require_getNative(),
+	    root = require_root();
+
+	/* Built-in method references that are verified to be native. */
+	var DataView = getNative(root, 'DataView');
+
+	_DataView = DataView;
+	return _DataView;
+}
+
+var _Map;
+var hasRequired_Map;
+
+function require_Map () {
+	if (hasRequired_Map) return _Map;
+	hasRequired_Map = 1;
+	var getNative = require_getNative(),
+	    root = require_root();
+
+	/* Built-in method references that are verified to be native. */
+	var Map = getNative(root, 'Map');
+
+	_Map = Map;
+	return _Map;
+}
+
+var _Promise;
+var hasRequired_Promise;
+
+function require_Promise () {
+	if (hasRequired_Promise) return _Promise;
+	hasRequired_Promise = 1;
+	var getNative = require_getNative(),
+	    root = require_root();
+
+	/* Built-in method references that are verified to be native. */
+	var Promise = getNative(root, 'Promise');
+
+	_Promise = Promise;
+	return _Promise;
+}
+
+var _Set;
+var hasRequired_Set;
+
+function require_Set () {
+	if (hasRequired_Set) return _Set;
+	hasRequired_Set = 1;
+	var getNative = require_getNative(),
+	    root = require_root();
+
+	/* Built-in method references that are verified to be native. */
+	var Set = getNative(root, 'Set');
+
+	_Set = Set;
+	return _Set;
+}
+
+var _WeakMap;
+var hasRequired_WeakMap;
+
+function require_WeakMap () {
+	if (hasRequired_WeakMap) return _WeakMap;
+	hasRequired_WeakMap = 1;
+	var getNative = require_getNative(),
+	    root = require_root();
+
+	/* Built-in method references that are verified to be native. */
+	var WeakMap = getNative(root, 'WeakMap');
+
+	_WeakMap = WeakMap;
+	return _WeakMap;
+}
+
+var _getTag;
+var hasRequired_getTag;
+
+function require_getTag () {
+	if (hasRequired_getTag) return _getTag;
+	hasRequired_getTag = 1;
+	var DataView = require_DataView(),
+	    Map = require_Map(),
+	    Promise = require_Promise(),
+	    Set = require_Set(),
+	    WeakMap = require_WeakMap(),
+	    baseGetTag = require_baseGetTag(),
+	    toSource = require_toSource();
+
+	/** `Object#toString` result references. */
+	var mapTag = '[object Map]',
+	    objectTag = '[object Object]',
+	    promiseTag = '[object Promise]',
+	    setTag = '[object Set]',
+	    weakMapTag = '[object WeakMap]';
+
+	var dataViewTag = '[object DataView]';
+
+	/** Used to detect maps, sets, and weakmaps. */
+	var dataViewCtorString = toSource(DataView),
+	    mapCtorString = toSource(Map),
+	    promiseCtorString = toSource(Promise),
+	    setCtorString = toSource(Set),
+	    weakMapCtorString = toSource(WeakMap);
+
+	/**
+	 * Gets the `toStringTag` of `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	var getTag = baseGetTag;
+
+	// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+	if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+	    (Map && getTag(new Map) != mapTag) ||
+	    (Promise && getTag(Promise.resolve()) != promiseTag) ||
+	    (Set && getTag(new Set) != setTag) ||
+	    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+	  getTag = function(value) {
+	    var result = baseGetTag(value),
+	        Ctor = result == objectTag ? value.constructor : undefined,
+	        ctorString = Ctor ? toSource(Ctor) : '';
+
+	    if (ctorString) {
+	      switch (ctorString) {
+	        case dataViewCtorString: return dataViewTag;
+	        case mapCtorString: return mapTag;
+	        case promiseCtorString: return promiseTag;
+	        case setCtorString: return setTag;
+	        case weakMapCtorString: return weakMapTag;
+	      }
+	    }
+	    return result;
+	  };
+	}
+
+	_getTag = getTag;
+	return _getTag;
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+
+var isObjectLike_1;
+var hasRequiredIsObjectLike;
+
+function requireIsObjectLike () {
+	if (hasRequiredIsObjectLike) return isObjectLike_1;
+	hasRequiredIsObjectLike = 1;
+	function isObjectLike(value) {
+	  return value != null && typeof value == 'object';
+	}
+
+	isObjectLike_1 = isObjectLike;
+	return isObjectLike_1;
+}
+
+var _baseIsArguments;
+var hasRequired_baseIsArguments;
+
+function require_baseIsArguments () {
+	if (hasRequired_baseIsArguments) return _baseIsArguments;
+	hasRequired_baseIsArguments = 1;
+	var baseGetTag = require_baseGetTag(),
+	    isObjectLike = requireIsObjectLike();
+
+	/** `Object#toString` result references. */
+	var argsTag = '[object Arguments]';
+
+	/**
+	 * The base implementation of `_.isArguments`.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	 */
+	function baseIsArguments(value) {
+	  return isObjectLike(value) && baseGetTag(value) == argsTag;
+	}
+
+	_baseIsArguments = baseIsArguments;
+	return _baseIsArguments;
+}
+
+var isArguments_1;
+var hasRequiredIsArguments;
+
+function requireIsArguments () {
+	if (hasRequiredIsArguments) return isArguments_1;
+	hasRequiredIsArguments = 1;
+	var baseIsArguments = require_baseIsArguments(),
+	    isObjectLike = requireIsObjectLike();
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/** Built-in value references. */
+	var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+	/**
+	 * Checks if `value` is likely an `arguments` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArguments(function() { return arguments; }());
+	 * // => true
+	 *
+	 * _.isArguments([1, 2, 3]);
+	 * // => false
+	 */
+	var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+	  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
+	    !propertyIsEnumerable.call(value, 'callee');
+	};
+
+	isArguments_1 = isArguments;
+	return isArguments_1;
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+
+var isArray_1;
+var hasRequiredIsArray;
+
+function requireIsArray () {
+	if (hasRequiredIsArray) return isArray_1;
+	hasRequiredIsArray = 1;
+	var isArray = Array.isArray;
+
+	isArray_1 = isArray;
+	return isArray_1;
+}
+
+/** Used as references for various `Number` constants. */
+
+var isLength_1;
+var hasRequiredIsLength;
+
+function requireIsLength () {
+	if (hasRequiredIsLength) return isLength_1;
+	hasRequiredIsLength = 1;
+	var MAX_SAFE_INTEGER = 9007199254740991;
+
+	/**
+	 * Checks if `value` is a valid array-like length.
+	 *
+	 * **Note:** This method is loosely based on
+	 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	 * @example
+	 *
+	 * _.isLength(3);
+	 * // => true
+	 *
+	 * _.isLength(Number.MIN_VALUE);
+	 * // => false
+	 *
+	 * _.isLength(Infinity);
+	 * // => false
+	 *
+	 * _.isLength('3');
+	 * // => false
+	 */
+	function isLength(value) {
+	  return typeof value == 'number' &&
+	    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+
+	isLength_1 = isLength;
+	return isLength_1;
+}
+
+var isArrayLike_1;
+var hasRequiredIsArrayLike;
+
+function requireIsArrayLike () {
+	if (hasRequiredIsArrayLike) return isArrayLike_1;
+	hasRequiredIsArrayLike = 1;
+	var isFunction = requireIsFunction(),
+	    isLength = requireIsLength();
+
+	/**
+	 * Checks if `value` is array-like. A value is considered array-like if it's
+	 * not a function and has a `value.length` that's an integer greater than or
+	 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	 * @example
+	 *
+	 * _.isArrayLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLike(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLike('abc');
+	 * // => true
+	 *
+	 * _.isArrayLike(_.noop);
+	 * // => false
+	 */
+	function isArrayLike(value) {
+	  return value != null && isLength(value.length) && !isFunction(value);
+	}
+
+	isArrayLike_1 = isArrayLike;
+	return isArrayLike_1;
+}
+
+var isBuffer = {exports: {}};
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+
+var stubFalse_1;
+var hasRequiredStubFalse;
+
+function requireStubFalse () {
+	if (hasRequiredStubFalse) return stubFalse_1;
+	hasRequiredStubFalse = 1;
+	function stubFalse() {
+	  return false;
+	}
+
+	stubFalse_1 = stubFalse;
+	return stubFalse_1;
+}
+
+isBuffer.exports;
+
+var hasRequiredIsBuffer;
+
+function requireIsBuffer () {
+	if (hasRequiredIsBuffer) return isBuffer.exports;
+	hasRequiredIsBuffer = 1;
+	(function (module, exports) {
+		var root = require_root(),
+		    stubFalse = requireStubFalse();
+
+		/** Detect free variable `exports`. */
+		var freeExports = exports && !exports.nodeType && exports;
+
+		/** Detect free variable `module`. */
+		var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+		/** Detect the popular CommonJS extension `module.exports`. */
+		var moduleExports = freeModule && freeModule.exports === freeExports;
+
+		/** Built-in value references. */
+		var Buffer = moduleExports ? root.Buffer : undefined;
+
+		/* Built-in method references for those with the same name as other `lodash` methods. */
+		var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+		/**
+		 * Checks if `value` is a buffer.
+		 *
+		 * @static
+		 * @memberOf _
+		 * @since 4.3.0
+		 * @category Lang
+		 * @param {*} value The value to check.
+		 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+		 * @example
+		 *
+		 * _.isBuffer(new Buffer(2));
+		 * // => true
+		 *
+		 * _.isBuffer(new Uint8Array(2));
+		 * // => false
+		 */
+		var isBuffer = nativeIsBuffer || stubFalse;
+
+		module.exports = isBuffer; 
+	} (isBuffer, isBuffer.exports));
+	return isBuffer.exports;
+}
+
+var _baseIsTypedArray;
+var hasRequired_baseIsTypedArray;
+
+function require_baseIsTypedArray () {
+	if (hasRequired_baseIsTypedArray) return _baseIsTypedArray;
+	hasRequired_baseIsTypedArray = 1;
+	var baseGetTag = require_baseGetTag(),
+	    isLength = requireIsLength(),
+	    isObjectLike = requireIsObjectLike();
+
+	/** `Object#toString` result references. */
+	var argsTag = '[object Arguments]',
+	    arrayTag = '[object Array]',
+	    boolTag = '[object Boolean]',
+	    dateTag = '[object Date]',
+	    errorTag = '[object Error]',
+	    funcTag = '[object Function]',
+	    mapTag = '[object Map]',
+	    numberTag = '[object Number]',
+	    objectTag = '[object Object]',
+	    regexpTag = '[object RegExp]',
+	    setTag = '[object Set]',
+	    stringTag = '[object String]',
+	    weakMapTag = '[object WeakMap]';
+
+	var arrayBufferTag = '[object ArrayBuffer]',
+	    dataViewTag = '[object DataView]',
+	    float32Tag = '[object Float32Array]',
+	    float64Tag = '[object Float64Array]',
+	    int8Tag = '[object Int8Array]',
+	    int16Tag = '[object Int16Array]',
+	    int32Tag = '[object Int32Array]',
+	    uint8Tag = '[object Uint8Array]',
+	    uint8ClampedTag = '[object Uint8ClampedArray]',
+	    uint16Tag = '[object Uint16Array]',
+	    uint32Tag = '[object Uint32Array]';
+
+	/** Used to identify `toStringTag` values of typed arrays. */
+	var typedArrayTags = {};
+	typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+	typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+	typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+	typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+	typedArrayTags[uint32Tag] = true;
+	typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+	typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+	typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+	typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+	typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+	typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+	typedArrayTags[setTag] = typedArrayTags[stringTag] =
+	typedArrayTags[weakMapTag] = false;
+
+	/**
+	 * The base implementation of `_.isTypedArray` without Node.js optimizations.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	 */
+	function baseIsTypedArray(value) {
+	  return isObjectLike(value) &&
+	    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+	}
+
+	_baseIsTypedArray = baseIsTypedArray;
+	return _baseIsTypedArray;
+}
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+
+var _baseUnary;
+var hasRequired_baseUnary;
+
+function require_baseUnary () {
+	if (hasRequired_baseUnary) return _baseUnary;
+	hasRequired_baseUnary = 1;
+	function baseUnary(func) {
+	  return function(value) {
+	    return func(value);
+	  };
+	}
+
+	_baseUnary = baseUnary;
+	return _baseUnary;
+}
+
+var _nodeUtil = {exports: {}};
+
+_nodeUtil.exports;
+
+var hasRequired_nodeUtil;
+
+function require_nodeUtil () {
+	if (hasRequired_nodeUtil) return _nodeUtil.exports;
+	hasRequired_nodeUtil = 1;
+	(function (module, exports) {
+		var freeGlobal = require_freeGlobal();
+
+		/** Detect free variable `exports`. */
+		var freeExports = exports && !exports.nodeType && exports;
+
+		/** Detect free variable `module`. */
+		var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+		/** Detect the popular CommonJS extension `module.exports`. */
+		var moduleExports = freeModule && freeModule.exports === freeExports;
+
+		/** Detect free variable `process` from Node.js. */
+		var freeProcess = moduleExports && freeGlobal.process;
+
+		/** Used to access faster Node.js helpers. */
+		var nodeUtil = (function() {
+		  try {
+		    // Use `util.types` for Node.js 10+.
+		    var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+		    if (types) {
+		      return types;
+		    }
+
+		    // Legacy `process.binding('util')` for Node.js < 10.
+		    return freeProcess && freeProcess.binding && freeProcess.binding('util');
+		  } catch (e) {}
+		}());
+
+		module.exports = nodeUtil; 
+	} (_nodeUtil, _nodeUtil.exports));
+	return _nodeUtil.exports;
+}
+
+var isTypedArray_1;
+var hasRequiredIsTypedArray;
+
+function requireIsTypedArray () {
+	if (hasRequiredIsTypedArray) return isTypedArray_1;
+	hasRequiredIsTypedArray = 1;
+	var baseIsTypedArray = require_baseIsTypedArray(),
+	    baseUnary = require_baseUnary(),
+	    nodeUtil = require_nodeUtil();
+
+	/* Node.js helper references. */
+	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+	/**
+	 * Checks if `value` is classified as a typed array.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	 * @example
+	 *
+	 * _.isTypedArray(new Uint8Array);
+	 * // => true
+	 *
+	 * _.isTypedArray([]);
+	 * // => false
+	 */
+	var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+	isTypedArray_1 = isTypedArray;
+	return isTypedArray_1;
+}
+
+var isEmpty_1;
+var hasRequiredIsEmpty;
+
+function requireIsEmpty () {
+	if (hasRequiredIsEmpty) return isEmpty_1;
+	hasRequiredIsEmpty = 1;
+	var baseKeys = require_baseKeys(),
+	    getTag = require_getTag(),
+	    isArguments = requireIsArguments(),
+	    isArray = requireIsArray(),
+	    isArrayLike = requireIsArrayLike(),
+	    isBuffer = requireIsBuffer(),
+	    isPrototype = require_isPrototype(),
+	    isTypedArray = requireIsTypedArray();
+
+	/** `Object#toString` result references. */
+	var mapTag = '[object Map]',
+	    setTag = '[object Set]';
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/**
+	 * Checks if `value` is an empty object, collection, map, or set.
+	 *
+	 * Objects are considered empty if they have no own enumerable string keyed
+	 * properties.
+	 *
+	 * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+	 * jQuery-like collections are considered empty if they have a `length` of `0`.
+	 * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+	 * @example
+	 *
+	 * _.isEmpty(null);
+	 * // => true
+	 *
+	 * _.isEmpty(true);
+	 * // => true
+	 *
+	 * _.isEmpty(1);
+	 * // => true
+	 *
+	 * _.isEmpty([1, 2, 3]);
+	 * // => false
+	 *
+	 * _.isEmpty({ 'a': 1 });
+	 * // => false
+	 */
+	function isEmpty(value) {
+	  if (value == null) {
+	    return true;
+	  }
+	  if (isArrayLike(value) &&
+	      (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
+	        isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+	    return !value.length;
+	  }
+	  var tag = getTag(value);
+	  if (tag == mapTag || tag == setTag) {
+	    return !value.size;
+	  }
+	  if (isPrototype(value)) {
+	    return !baseKeys(value).length;
+	  }
+	  for (var key in value) {
+	    if (hasOwnProperty.call(value, key)) {
+	      return false;
+	    }
+	  }
+	  return true;
+	}
+
+	isEmpty_1 = isEmpty;
+	return isEmpty_1;
+}
+
+var isEmptyExports = requireIsEmpty();
+const _isEmpty = /*@__PURE__*/getDefaultExportFromCjs(isEmptyExports);
+
+const textStyles = {
+  fontWeight: {
+    semibold: 590,
+    regular: 400
+  },
+  letterSpacing: {
+    default: "normal"
+  }
+};
+
+const drawerTypography = {
+  fontFamily: "-apple-system,system-ui,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Fira Sans,Ubuntu,Oxygen,Oxygen Sans,Cantarell,Droid Sans,Apple Color Emoji,Segoe UI Emoji,Segoe UI Emoji,Segoe UI Symbol,Lucida Grande,Helvetica,Arial,sans-serif",
+  displayL: {
+    fontSize: "80px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "92px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  displayM: {
+    fontSize: "40px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "52px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  headingL: {
+    fontSize: "32px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "44px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  headingM: {
+    fontSize: "28px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "40px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  headingS: {
+    fontSize: "24px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "36px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  semiBoldLabelL: {
+    fontSize: "20px",
+    lineHeight: "28px",
+    fontWeight: textStyles.fontWeight.semibold,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  semiBoldLabelM: {
+    fontSize: "16px",
+    lineHeight: "24px",
+    fontWeight: textStyles.fontWeight.semibold,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  semiBoldLabelS: {
+    fontSize: "14px",
+    lineHeight: "20px",
+    fontWeight: textStyles.fontWeight.semibold,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  semiBoldLabelXs: {
+    fontSize: "12px",
+    lineHeight: "16px",
+    fontWeight: textStyles.fontWeight.semibold,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  semiBoldLabelXxs: {
+    fontSize: "10px",
+    lineHeight: "14px",
+    fontWeight: textStyles.fontWeight.semibold,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  regularLabelL: {
+    fontSize: "20px",
+    lineHeight: "28px",
+    fontWeight: textStyles.fontWeight.regular,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  regularLabelM: {
+    fontSize: "16px",
+    lineHeight: "24px",
+    fontWeight: textStyles.fontWeight.regular,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  regularLabelS: {
+    fontSize: "14px",
+    lineHeight: "20px",
+    fontWeight: textStyles.fontWeight.regular,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  regularLabelXs: {
+    fontSize: "12px",
+    lineHeight: "16px",
+    fontWeight: textStyles.fontWeight.regular,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  regularLabelXxs: {
+    fontSize: "10px",
+    lineHeight: "14px",
+    fontWeight: textStyles.fontWeight.regular,
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  textXl: {
+    fontSize: "20px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "28px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  textL: {
+    fontSize: "16px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "24px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  textM: {
+    fontSize: "14px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "20px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  subtextM: {
+    fontSize: "12px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "16px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  subtextS: {
+    fontSize: "10px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "14px",
+    letterSpacing: textStyles.letterSpacing.default
+  },
+  semiBoldLinkXL: {
+    fontSize: "20px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "28px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  semiBoldLinkL: {
+    fontSize: "16px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "24px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  semiBoldLinkM: {
+    fontSize: "14px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "20px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  semiBoldLinkS: {
+    fontSize: "12px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "16px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  semiBoldLinkXs: {
+    fontSize: "10px",
+    fontWeight: textStyles.fontWeight.semibold,
+    lineHeight: "14px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  regularLinkXL: {
+    fontSize: "20px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "20px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  regularLinkL: {
+    fontSize: "16px",
+    fontWeight: textStyles.fontWeight.regular,
+    lineHeight: "24px",
+    letterSpacing: textStyles.letterSpacing.default,
+    textDecoration: "underline"
+  },
+  h1: {
+    fontSize: "26px",
+    fontWeight: 590,
+    lineHeight: "32px"
+  },
+  h2: {
+    fontSize: "22px",
+    fontWeight: 590,
+    lineHeight: "26px"
+  },
+  h3: {
+    fontSize: "17px",
+    fontWeight: 590,
+    lineHeight: "22px"
+  },
+  h4: {
+    fontSize: "15px",
+    fontWeight: 590,
+    lineHeight: "20px"
+  },
+  h5: {
+    fontSize: "14px",
+    fontWeight: 590,
+    lineHeight: "20px"
+  },
+  headline: {
+    fontSize: "13px",
+    fontWeight: 590,
+    lineHeight: "16px"
+  },
+  body: {
+    fontSize: "13px",
+    lineHeight: "16px",
+    fontWeight: 400
+  },
+  callout: {
+    fontSize: "13px",
+    fontWeight: 510,
+    lineHeight: "15px"
+  },
+  subHeadline1: {
+    fontSize: "14px",
+    lineHeight: "20px",
+    fontWeight: 400
+  },
+  subHeadline2: {
+    fontSize: "13px",
+    lineHeight: "20px",
+    fontWeight: 400
+  },
+  footNote: {
+    fontSize: "12px",
+    lineHeight: "13px",
+    fontWeight: 400
+  },
+  caption1: {
+    fontSize: "10px",
+    lineHeight: "13px",
+    fontWeight: 400
+  },
+  caption2: {
+    fontSize: "10px",
+    lineHeight: "13px",
+    fontWeight: 510
+  }
+};
+const muiTheme = createTheme({
+  palette: {
+    primary: {
+      main: "#1E221E",
+      contrastText: "#ffffff"
+    },
+    secondary: {
+      main: "#0A9083",
+      contrastText: "#000000"
+    },
+    error: {
+      main: "#ED1D31",
+      contrastText: "#ffffff"
+    },
+    warning: {
+      main: "#F3800D",
+      contrastText: "#000000"
+    },
+    info: {
+      main: "#0881EA",
+      contrastText: "#000000"
+    },
+    success: {
+      main: "#0AB22C",
+      contrastText: "#000000"
+    },
+    background: {
+      default: "#F7F9FC"
+    }
+  },
+  typography: drawerTypography,
+  components: {
+    MuiTypography: {
+      defaultProps: {
+        variantMapping: {
+          h1: "h1",
+          h2: "h2",
+          h3: "h3",
+          h4: "h4",
+          headline: "h5",
+          body: "span",
+          callout: "span",
+          subHeadline1: "span",
+          subHeadline2: "span",
+          footNote: "span",
+          caption1: "span",
+          caption2: "span"
+        }
+      }
+    },
+    MuiButton: {
+      defaultProps: {
+        disableElevation: true,
+        size: "large"
+      },
+      styleOverrides: {
+        root: {
+          textTransform: "none",
+          fontSize: "14px",
+          borderRadius: "8px"
+        },
+        text: {
+          textDecoration: "underline",
+          "&:hover": {
+            backgroundColor: "transparent",
+            textDecoration: "underline"
+          },
+          padding: "0px 8px",
+          textAlign: "left"
+        }
+      }
+    },
+    MuiTab: {
+      styleOverrides: {
+        root: {
+          textTransform: "none",
+          fontSize: "14px"
+        }
+      }
+    },
+    MuiChip: {
+      defaultProps: {
+        size: "small"
+      },
+      styleOverrides: {
+        root: {
+          paddingLeft: "5px",
+          paddingRight: "5px"
+        }
+      }
+    },
+    MuiPaper: {
+      styleOverrides: {
+        root: {
+          borderRadius: "16px"
+        }
+      }
+    },
+    MuiCard: {
+      defaultProps: {
+        variant: "outlined"
+      },
+      styleOverrides: {
+        root: {
+          borderRadius: "16px"
+        }
+      }
+    },
+    MuiAutocomplete: {
+      styleOverrides: {
+        root: {
+          "& .MuiAutocomplete-inputRoot": {
+            paddingLeft: "14px"
+          }
+        }
+      }
+    },
+    MuiLink: {
+      styleOverrides: {
+        root: {
+          fontWeight: "bold",
+          "&:hover": {
+            cursor: "pointer"
+          }
+        }
+      },
+      defaultProps: {
+        variant: "body"
+      }
+    },
+    MuiTextField: {
+      styleOverrides: {
+        root: {
+          "& .MuiInputBase-root": {
+            borderRadius: "8px"
+          }
+        }
+      }
+    },
+    MuiFormControl: {
+      styleOverrides: {
+        root: {
+          "& .MuiInputBase-root": {
+            borderRadius: "8px"
+          }
+        }
+      }
+    },
+    MuiDrawer: {
+      styleOverrides: {
+        paper: {
+          borderRadius: 0
+        }
+      }
+    }
+  }
+});
+
+const DRAWER_TYPES = {
+  INFORMATION: "information",
+  INPUT: "input"
+};
+const INFORMATION_SUBTYPES = {
+  PROGRESS: "progress",
+  PASSIVE: "passive"
+};
+const INPUT_SUBTYPES = {
+  DEFAULT: "default",
+  DESTRUCTIVE: "destructive"
+};
+const DRAWER_CONFIGS = {
+  [DRAWER_TYPES.INFORMATION]: {
+    [INFORMATION_SUBTYPES.PROGRESS]: {
+      DISMISSIBLE: "partial"
+    },
+    [INFORMATION_SUBTYPES.PASSIVE]: {
+      DISMISSIBLE: "full"
+    }
+  },
+  [DRAWER_TYPES.INPUT]: {
+    [INPUT_SUBTYPES.DEFAULT]: {
+      DISMISSIBLE: "partial"
+    },
+    [INPUT_SUBTYPES.DESTRUCTIVE]: {
+      DISMISSIBLE: "partial"
+    }
+  }
+};
+const TERTIARY_CTA_TYPES = {
+  DEFAULT: "default",
+  DESTRUCTIVE: "destructive"
+};
+
+const MuiDrawer = (props) => {
+  const [actionsMaxWidth, setActionsMaxWidth] = useState("50%");
+  const drawerRef = useRef(null);
+  const parentTheme = useTheme();
+  const currentTheme = _isEmpty(parentTheme) ? muiTheme : {
+    ...parentTheme,
+    typography: {
+      ...parentTheme.typography,
+      ...drawerTypography
+    }
+  };
+  const subtype = props.type === DRAWER_TYPES.INFORMATION ? props.subtype : props.type === DRAWER_TYPES.INPUT ? props.subtype : "default";
+  const {
+    anchor = "right",
+    wrapperClassName,
+    bodyWrapperClassName,
+    open,
+    type,
+    title,
+    subTitle,
+    description,
+    onClose,
+    children,
+    actions,
+    width,
+    maxWidth,
+    showActions = true,
+    showDivider = true,
+    showCloseIcon = true,
+    tertiaryCtaType = "default",
+    ...rest
+  } = props;
+  const {
+    primaryCtaTitle,
+    secondaryCtaTitle,
+    isPrimaryCtaLoading = false,
+    isPrimaryCtaDisabled,
+    isSecondaryCtaLoading = false,
+    isSecondaryCtaDisabled,
+    onPrimaryCtaClick = _noop,
+    onSecondaryCtaClick = _noop,
+    tertiaryCtaTitle,
+    tertiaryCtaStartIcon,
+    isTertiaryCtaLoading = false,
+    isTertiaryCtaDisabled,
+    onTertiaryCtaClick = _noop,
+    primaryCtaTooltipText,
+    secondaryCtaTooltipText,
+    tertiaryCtaTooltipText
+  } = actions || {};
+  const config = DRAWER_CONFIGS[type][subtype] || DRAWER_CONFIGS[type].default;
+  const showFooter = showActions && (primaryCtaTitle || secondaryCtaTitle || tertiaryCtaTitle);
+  const footerCtaCount = [
+    primaryCtaTitle,
+    secondaryCtaTitle,
+    tertiaryCtaTitle
+  ].filter(Boolean).length;
+  const handleClose = () => {
+    if (config?.DISMISSIBLE === "full") {
+      onClose();
+    }
+  };
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      if (drawerRef.current) {
+        const width2 = drawerRef.current.getBoundingClientRect().width;
+        if (width2 < 600) setActionsMaxWidth("100%");
+        if (width2 >= 600) setActionsMaxWidth("50%");
+        if (width2 >= 900) setActionsMaxWidth("33%");
+        if (width2 >= 1200) setActionsMaxWidth("25%");
+      }
+    }, 0);
+    return () => clearTimeout(timer);
+  }, [drawerRef.current]);
+  return /* @__PURE__ */ jsx(ThemeProvider, { theme: currentTheme, children: /* @__PURE__ */ jsx(
+    Drawer,
+    {
+      className: classNames("vi-drawer", wrapperClassName),
+      open,
+      anchor,
+      onClose: handleClose,
+      ...rest,
+      children: /* @__PURE__ */ jsxs("div", { ref: drawerRef, style: { width, maxWidth }, className: "h-fill", children: [
+        title && /* @__PURE__ */ jsxs("div", { className: "vi-drawer-title", children: [
+          /* @__PURE__ */ jsxs("div", { className: "d-f ai-c jc-sb", children: [
+            /* @__PURE__ */ jsxs("div", { className: "d-f flex-dir-col gap-8", children: [
+              /* @__PURE__ */ jsx(Typography, { variant: "semiBoldLabelL", children: title }),
+              subTitle && /* @__PURE__ */ jsx(Typography, { variant: "subtextM", children: subTitle })
+            ] }),
+            showCloseIcon && /* @__PURE__ */ jsx(
+              CloseIcon,
+              {
+                fontSize: "small",
+                className: "close-icon",
+                "aria-label": "Close drawer",
+                onClick: onClose
+              }
+            )
+          ] }),
+          description && /* @__PURE__ */ jsx(
+            Typography,
+            {
+              component: "div",
+              className: "description",
+              variant: "subtextM",
+              children: description
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: classNames(
+              "drawer-children",
+              title && showFooter ? "with-header-footer" : title ? "with-header" : showFooter ? "with-footer" : "",
+              footerCtaCount === 3 ? "three-ctas" : "",
+              footerCtaCount === 2 ? "two-ctas" : "",
+              footerCtaCount === 1 ? "one-cta" : "",
+              showFooter && !showDivider ? "no-divider" : "",
+              bodyWrapperClassName
+            ),
+            children
+          }
+        ),
+        showFooter && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: classNames(
+              "vi-drawer-actions",
+              showDivider ? "divider" : "",
+              tertiaryCtaTitle ? "tertiary-cta" : ""
+            ),
+            children: [
+              tertiaryCtaTitle && /* @__PURE__ */ jsx(
+                Tooltip,
+                {
+                  title: isTertiaryCtaDisabled ? tertiaryCtaTooltipText : "",
+                  arrow: true,
+                  children: /* @__PURE__ */ jsx(
+                    LoadingButton,
+                    {
+                      className: classNames(
+                        tertiaryCtaType === TERTIARY_CTA_TYPES.DESTRUCTIVE ? "tertiary-cta-destructive" : ""
+                      ),
+                      variant: "text",
+                      onClick: onTertiaryCtaClick,
+                      startIcon: tertiaryCtaStartIcon,
+                      loading: isTertiaryCtaLoading,
+                      disabled: isTertiaryCtaDisabled !== void 0 ? isTertiaryCtaDisabled : !!(isPrimaryCtaLoading || isSecondaryCtaLoading),
+                      children: tertiaryCtaTitle
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: { width: actionsMaxWidth },
+                  className: "vi-drawer-action-ctas",
+                  children: [
+                    secondaryCtaTitle && /* @__PURE__ */ jsx(
+                      Tooltip,
+                      {
+                        title: isSecondaryCtaDisabled ? secondaryCtaTooltipText : "",
+                        arrow: true,
+                        children: /* @__PURE__ */ jsx(
+                          LoadingButton,
+                          {
+                            className: "vi-drawer-cta",
+                            variant: "outlined",
+                            onClick: onSecondaryCtaClick,
+                            loading: isSecondaryCtaLoading,
+                            disabled: isSecondaryCtaDisabled !== void 0 ? isSecondaryCtaDisabled : !!(isPrimaryCtaLoading || isTertiaryCtaLoading),
+                            children: secondaryCtaTitle
+                          }
+                        )
+                      }
+                    ),
+                    primaryCtaTitle && /* @__PURE__ */ jsx(
+                      Tooltip,
+                      {
+                        title: isPrimaryCtaDisabled ? primaryCtaTooltipText : "",
+                        arrow: true,
+                        children: /* @__PURE__ */ jsx(
+                          LoadingButton,
+                          {
+                            className: classNames(
+                              "vi-drawer-cta",
+                              subtype === "destructive" ? "destructive" : ""
+                            ),
+                            variant: "contained",
+                            onClick: onPrimaryCtaClick,
+                            loading: isPrimaryCtaLoading,
+                            disabled: isPrimaryCtaDisabled !== void 0 ? isPrimaryCtaDisabled : !!(isSecondaryCtaLoading || isTertiaryCtaLoading),
+                            children: primaryCtaTitle
+                          }
+                        )
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        )
+      ] })
+    }
+  ) });
+};
+
+export { DRAWER_CONFIGS, DRAWER_TYPES, INFORMATION_SUBTYPES, INPUT_SUBTYPES, MuiDrawer, TERTIARY_CTA_TYPES };